@subsection upgrade_720_changes_methods Other changes
+* *MMgt_TShared* class definition has been removed - Standard_Transient should be used instead (MMgt_TShared is marked as deprecated typedef of Standard_Transient for smooth migration).
* Class GeomPlate_BuildPlateSurface accepts base class Adaptor3d_HCurve (instead of inherited Adaptor3d_HCurveOnSurface accepted earlier).
* Types GeomPlate_Array1OfHCurveOnSurface and GeomPlate_HArray1OfHCurveOnSurface have been replaced with GeomPlate_Array1OfHCurve and GeomPlate_HArray1OfHCurve correspondingly (accept base class Adaptor3d_HCurve instead of Adaptor3d_HCurveOnSurface).
* Enumeration *Image_PixMap::ImgFormat*, previously declared as nested enumeration within class *Image_PixMap*, has been moved to global namespace as *Image_Format* following OCCT coding rules.
Change of coordinates
---------------------
-*TopLoc_Datum3D* class represents a change of elementary coordinates. Such changes must be shared so this class inherits from *MMgt_TShared*. The coordinate is represented by a transformation *gp_Trsfpackage*. This transformation has no scaling factor.
+*TopLoc_Datum3D* class represents a change of elementary coordinates. Such changes must be shared so this class inherits from *Standard_Transient*. The coordinate is represented by a transformation *gp_Trsfpackage*. This transformation has no scaling factor.
@subsection occt_modat_5_2 Naming shapes, sub-shapes, their orientation and state
static Handle_Standard_Type aType1 = STANDARD_TYPE(TFunction_Driver);
if ( aType1.IsNull()) aType1 = STANDARD_TYPE(TFunction_Driver);
- 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_Type aType2 = STANDARD_TYPE(Standard_Transient);
+ if ( aType2.IsNull()) aType2 = STANDARD_TYPE(Standard_Transient);
- static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL};
+ static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,NULL};
static Handle_Standard_Type _aType = new Standard_Type("OCAFSample_Driver",
sizeof(OCAFSample_Driver),
1,
#include <V3d_Viewer.hxx>
#include <stdio.h>
-IMPLEMENT_STANDARD_RTTIEXT(AIS_LocalContext,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(AIS_LocalContext,Standard_Transient)
//=======================================================================
//function : AIS_LocalContext
#include <Standard_Integer.hxx>
#include <TColStd_SequenceOfInteger.hxx>
#include <AIS_SequenceOfInteractive.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <AIS_ClearMode.hxx>
#include <TopAbs_ShapeEnum.hxx>
#include <SelectMgr_ListOfFilter.hxx>
class AIS_LocalContext;
-DEFINE_STANDARD_HANDLE(AIS_LocalContext, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(AIS_LocalContext, Standard_Transient)
//! Defines a specific context for selection.
//! It becomes possible to:
//! - automatically highlight shapes and
//! InteractiveObjects (highlight of detected shape +
//! highlight of detected selectable...
-class AIS_LocalContext : public MMgt_TShared
+class AIS_LocalContext : public Standard_Transient
{
public:
//! stored in local status
Standard_EXPORT void RestoreActivatedModes() const;
- DEFINE_STANDARD_RTTIEXT(AIS_LocalContext,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(AIS_LocalContext,Standard_Transient)
private:
#include <Standard_OutOfRange.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Adaptor2d_HCurve2d,MMgt_TShared)
\ No newline at end of file
+IMPLEMENT_STANDARD_RTTIEXT(Adaptor2d_HCurve2d,Standard_Transient)
\ No newline at end of file
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Real.hxx>
#include <GeomAbs_Shape.hxx>
#include <Standard_Integer.hxx>
class Adaptor2d_HCurve2d;
-DEFINE_STANDARD_HANDLE(Adaptor2d_HCurve2d, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Adaptor2d_HCurve2d, Standard_Transient)
//! Root class for 2D curves manipulated by handles, on
//! which geometric algorithms work.
//! the curve by algorithms, which use it.
//! A derived specific class is provided:
//! Geom2dAdaptor_HCurve for a curve from the Geom2d package.
-class Adaptor2d_HCurve2d : public MMgt_TShared
+class Adaptor2d_HCurve2d : public Standard_Transient
{
public:
virtual Handle(Geom2d_BSplineCurve) BSpline() const;
- DEFINE_STANDARD_RTTIEXT(Adaptor2d_HCurve2d,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Adaptor2d_HCurve2d,Standard_Transient)
};
#include <Adaptor2d_HCurve2d.lxx>
#include <Standard_OutOfRange.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Adaptor3d_HCurve,MMgt_TShared)
\ No newline at end of file
+IMPLEMENT_STANDARD_RTTIEXT(Adaptor3d_HCurve,Standard_Transient)
\ No newline at end of file
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Real.hxx>
#include <GeomAbs_Shape.hxx>
#include <Standard_Integer.hxx>
class Adaptor3d_HCurve;
-DEFINE_STANDARD_HANDLE(Adaptor3d_HCurve, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Adaptor3d_HCurve, Standard_Transient)
//! Root class for 3D curves manipulated by handles, on
//! which geometric algorithms work.
//! - GeomAdaptor_HCurve for a curve from the Geom package
//! - Adaptor3d_HCurveOnSurface for a curve lying
//! on a surface from the Geom package.
-class Adaptor3d_HCurve : public MMgt_TShared
+class Adaptor3d_HCurve : public Standard_Transient
{
public:
Handle(Geom_OffsetCurve) OffsetCurve() const;
- DEFINE_STANDARD_RTTIEXT(Adaptor3d_HCurve,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Adaptor3d_HCurve,Standard_Transient)
protected:
#include <Standard_OutOfRange.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Adaptor3d_HSurface,MMgt_TShared)
\ No newline at end of file
+IMPLEMENT_STANDARD_RTTIEXT(Adaptor3d_HSurface,Standard_Transient)
\ No newline at end of file
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Real.hxx>
#include <GeomAbs_Shape.hxx>
#include <Standard_Integer.hxx>
class Adaptor3d_HSurface;
-DEFINE_STANDARD_HANDLE(Adaptor3d_HSurface, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Adaptor3d_HSurface, Standard_Transient)
//! Root class for surfaces manipulated by handles, on
//! which geometric algorithms work.
//! the surface by algorithms which use it.
//! A derived concrete class is provided:
//! GeomAdaptor_HSurface for a surface from the Geom package.
-class Adaptor3d_HSurface : public MMgt_TShared
+class Adaptor3d_HSurface : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Adaptor3d_HSurface,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Adaptor3d_HSurface,Standard_Transient)
protected:
#include <Precision.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Adaptor3d_HVertex,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Adaptor3d_HVertex,Standard_Transient)
Adaptor3d_HVertex::Adaptor3d_HVertex ()
{}
#include <gp_Pnt2d.hxx>
#include <Standard_Real.hxx>
#include <TopAbs_Orientation.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
class gp_Pnt2d;
class Adaptor2d_HCurve2d;
class Adaptor3d_HVertex;
-DEFINE_STANDARD_HANDLE(Adaptor3d_HVertex, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Adaptor3d_HVertex, Standard_Transient)
-class Adaptor3d_HVertex : public MMgt_TShared
+class Adaptor3d_HVertex : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Adaptor3d_HVertex,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Adaptor3d_HVertex,Standard_Transient)
protected:
#include <Standard_NotImplemented.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Adaptor3d_TopolTool,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Adaptor3d_TopolTool,Standard_Transient)
#define myInfinite Precision::Infinite()
class Adaptor3d_TopolTool;
-DEFINE_STANDARD_HANDLE(Adaptor3d_TopolTool, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Adaptor3d_TopolTool, Standard_Transient)
//! This class provides a default topological tool,
//! based on the Umin,Vmin,Umax,Vmax of an HSurface
//! inheriting from this class.
//! This class is used to instantiate algorithmes
//! as Intersection, outlines,...
-class Adaptor3d_TopolTool : public MMgt_TShared
+class Adaptor3d_TopolTool : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Adaptor3d_TopolTool,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Adaptor3d_TopolTool,Standard_Transient)
protected:
#include <AppDef_MultiPointConstraint.hxx>
#include <gp_Vec.hxx>
#include <gp_Vec2d.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_ConstructionError.hxx>
#include <Standard_DimensionError.hxx>
#include <Standard_OutOfRange.hxx>
#include <Standard_NotImplemented.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(AppDef_SmoothCriterion,MMgt_TShared)
\ No newline at end of file
+IMPLEMENT_STANDARD_RTTIEXT(AppDef_SmoothCriterion,Standard_Transient)
\ No newline at end of file
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <Standard_Real.hxx>
#include <FEmTool_HAssemblyTable.hxx>
class AppDef_SmoothCriterion;
-DEFINE_STANDARD_HANDLE(AppDef_SmoothCriterion, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(AppDef_SmoothCriterion, Standard_Transient)
//! defined criterion to smooth points in curve
-class AppDef_SmoothCriterion : public MMgt_TShared
+class AppDef_SmoothCriterion : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(AppDef_SmoothCriterion,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(AppDef_SmoothCriterion,Standard_Transient)
protected:
#include <AppParCurves_MultiPoint.hxx>
#include <gp_Pnt.hxx>
#include <gp_Pnt2d.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_DimensionError.hxx>
#include <Standard_OutOfRange.hxx>
#include <TColgp_HArray1OfPnt.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <Standard_Real.hxx>
#include <Standard_OStream.hxx>
-class MMgt_TShared;
+class Standard_Transient;
class Standard_OutOfRange;
class Standard_DimensionError;
class gp_Pnt;
- Handle(MMgt_TShared) ttabPoint;
- Handle(MMgt_TShared) ttabPoint2d;
+ Handle(Standard_Transient) ttabPoint;
+ Handle(Standard_Transient) ttabPoint2d;
Standard_Integer nbP;
Standard_Integer nbP2d;
#include <Standard_Type.hxx>
#include <TColStd_SequenceOfReal.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Approx_CurvlinFunc,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Approx_CurvlinFunc,Standard_Transient)
#ifdef OCCT_DEBUG_CHRONO
#include <OSD_Timer.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
#include <TColStd_HArray1OfReal.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <GeomAbs_Shape.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <Standard_Boolean.hxx>
class Approx_CurvlinFunc;
-DEFINE_STANDARD_HANDLE(Approx_CurvlinFunc, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Approx_CurvlinFunc, Standard_Transient)
//! defines an abstract curve with
//! curvilinear parametrization
-class Approx_CurvlinFunc : public MMgt_TShared
+class Approx_CurvlinFunc : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Approx_CurvlinFunc,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Approx_CurvlinFunc,Standard_Transient)
protected:
#include <Standard_OutOfRange.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Approx_SweepFunction,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Approx_SweepFunction,Standard_Transient)
// Standard_Boolean Approx_SweepFunction::D1(const Standard_Real Param,const Standard_Real First,const Standard_Real Last,TColgp_Array1OfPnt& Poles,TColgp_Array1OfVec& DPoles,TColgp_Array1OfPnt2d& Poles2d,TColgp_Array1OfVec2d& DPoles2d,TColStd_Array1OfReal& Weigths,TColStd_Array1OfReal& DWeigths)
Standard_Boolean Approx_SweepFunction::D1(const Standard_Real ,const Standard_Real ,const Standard_Real ,TColgp_Array1OfPnt& ,TColgp_Array1OfVec& ,TColgp_Array1OfPnt2d& ,TColgp_Array1OfVec2d& ,TColStd_Array1OfReal& ,TColStd_Array1OfReal& )
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Real.hxx>
#include <TColgp_Array1OfPnt.hxx>
class Approx_SweepFunction;
-DEFINE_STANDARD_HANDLE(Approx_SweepFunction, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Approx_SweepFunction, Standard_Transient)
//! defined the function used by SweepApproximation to
//! perform sweeping application.
-class Approx_SweepFunction : public MMgt_TShared
+class Approx_SweepFunction : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Approx_SweepFunction,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Approx_SweepFunction,Standard_Transient)
protected:
#include <Quantity_Color.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Aspect_Grid,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Aspect_Grid,Standard_Transient)
Aspect_Grid::Aspect_Grid(
const Standard_Real anXOrigin,
#include <Quantity_Color.hxx>
#include <Standard_Boolean.hxx>
#include <Aspect_GridDrawMode.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class Aspect_Grid;
-DEFINE_STANDARD_HANDLE(Aspect_Grid, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Aspect_Grid, Standard_Transient)
-class Aspect_Grid : public MMgt_TShared
+class Aspect_Grid : public Standard_Transient
{
public:
Standard_EXPORT virtual void Init() = 0;
- DEFINE_STANDARD_RTTIEXT(Aspect_Grid,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Aspect_Grid,Standard_Transient)
protected:
#include <Quantity_Color.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Aspect_Window,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Aspect_Window,Standard_Transient)
//-Aliases
//-Global data definitions
#include <Aspect_FBConfig.hxx>
#include <Aspect_FillMethod.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Quantity_Color.hxx>
#include <Aspect_GradientFillMethod.hxx>
#include <Aspect_TypeOfResize.hxx>
class Aspect_GradientBackground;
class Aspect_Window;
-DEFINE_STANDARD_HANDLE(Aspect_Window, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Aspect_Window, Standard_Transient)
//! Defines a window.
-class Aspect_Window : public MMgt_TShared
+class Aspect_Window : public Standard_Transient
{
public:
//! Returns native Window FB config (GLXFBConfig on Xlib)
Standard_EXPORT virtual Aspect_FBConfig NativeFBConfig() const = 0;
- DEFINE_STANDARD_RTTIEXT(Aspect_Window,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Aspect_Window,Standard_Transient)
protected:
#include <BOPDS_PaveBlock.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(BOPDS_CommonBlock,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(BOPDS_CommonBlock,Standard_Transient)
//=======================================================================
// function:
#include <BOPDS_ListOfPaveBlock.hxx>
#include <BOPCol_ListOfInteger.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <BOPCol_BaseAllocator.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
class BOPDS_CommonBlock;
-DEFINE_STANDARD_HANDLE(BOPDS_CommonBlock, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(BOPDS_CommonBlock, Standard_Transient)
//! The class BOPDS_CommonBlock is to store the information
//! b) face(s).<br>
//! First pave block in the common block (real pave block)
//! is always a pave block with the minimal index of the original edge.
-class BOPDS_CommonBlock : public MMgt_TShared
+class BOPDS_CommonBlock : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(BOPDS_CommonBlock,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(BOPDS_CommonBlock,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <algorithm>
-IMPLEMENT_STANDARD_RTTIEXT(BOPDS_PaveBlock,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(BOPDS_PaveBlock,Standard_Transient)
//=======================================================================
//function :
#include <Standard_Real.hxx>
#include <Bnd_Box.hxx>
#include <BOPCol_MapOfInteger.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <BOPDS_ListOfPaveBlock.hxx>
class BOPDS_Pave;
class BOPDS_PaveBlock;
-DEFINE_STANDARD_HANDLE(BOPDS_PaveBlock, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(BOPDS_PaveBlock, Standard_Transient)
//! The class BOPDS_PaveBlock is to store
//! the information about pave block on an edge.
//! Two adjacent paves on edge make up pave block.
-class BOPDS_PaveBlock : public MMgt_TShared
+class BOPDS_PaveBlock : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(BOPDS_PaveBlock,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(BOPDS_PaveBlock,Standard_Transient)
protected:
#include <TColStd_HArray1OfInteger.hxx>
#include <TopLoc_Location.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(BRep_CurveRepresentation,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(BRep_CurveRepresentation,Standard_Transient)
//=======================================================================
//function : BRep_CurveRepresentation
#include <Standard_Type.hxx>
#include <TopLoc_Location.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <GeomAbs_Shape.hxx>
class Standard_DomainError;
class BRep_CurveRepresentation;
-DEFINE_STANDARD_HANDLE(BRep_CurveRepresentation, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(BRep_CurveRepresentation, Standard_Transient)
//! Root class for the curve representations. Contains
//! a location.
-class BRep_CurveRepresentation : public MMgt_TShared
+class BRep_CurveRepresentation : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(BRep_CurveRepresentation,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(BRep_CurveRepresentation,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TopLoc_Location.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(BRep_PointRepresentation,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(BRep_PointRepresentation,Standard_Transient)
//=======================================================================
//function : BRep_PointRepresentation
#include <TopLoc_Location.hxx>
#include <Standard_Real.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
class Standard_DomainError;
class TopLoc_Location;
class BRep_PointRepresentation;
-DEFINE_STANDARD_HANDLE(BRep_PointRepresentation, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(BRep_PointRepresentation, Standard_Transient)
//! Root class for the points representations.
//! Contains a location and a parameter.
-class BRep_PointRepresentation : public MMgt_TShared
+class BRep_PointRepresentation : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(BRep_PointRepresentation,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(BRep_PointRepresentation,Standard_Transient)
protected:
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_MapOfOrientedShape.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(BRepAlgo_AsDes,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(BRepAlgo_AsDes,Standard_Transient)
//=======================================================================
//function : BRepAlgo_AsDes
#include <Standard_Type.hxx>
#include <TopTools_DataMapOfShapeListOfShape.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TopTools_ListOfShape.hxx>
#include <Standard_Boolean.hxx>
class Standard_ConstructionError;
class BRepAlgo_AsDes;
-DEFINE_STANDARD_HANDLE(BRepAlgo_AsDes, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(BRepAlgo_AsDes, Standard_Transient)
//! SD to store descendants and ascendants of Shapes.
-class BRepAlgo_AsDes : public MMgt_TShared
+class BRepAlgo_AsDes : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(BRepAlgo_AsDes,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(BRepAlgo_AsDes,Standard_Transient)
protected:
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_ListOfShape.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(BRepAlgo_EdgeConnector,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(BRepAlgo_EdgeConnector,Standard_Transient)
//=======================================================================
//function : Create
#include <BRepAlgo_DataMapOfShapeBoolean.hxx>
#include <TopOpeBRepBuild_BlockBuilder.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TopoDS_Edge;
class TopoDS_Shape;
class BRepAlgo_EdgeConnector;
-DEFINE_STANDARD_HANDLE(BRepAlgo_EdgeConnector, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(BRepAlgo_EdgeConnector, Standard_Transient)
//! Used by DSAccess to reconstruct an EdgeSet of connected edges. The result produced by
//! MakeBlock is a list of non-standard TopoDS_wire,
//! which can present connexions of edge of order > 2
//! in certain vertex. The method IsWire
//! indicates standard/non-standard character of all wire produced.
-class BRepAlgo_EdgeConnector : public MMgt_TShared
+class BRepAlgo_EdgeConnector : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(BRepAlgo_EdgeConnector,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(BRepAlgo_EdgeConnector,Standard_Transient)
protected:
#include <IntSurf_PntOn2S.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(BRepApprox_ApproxLine,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(BRepApprox_ApproxLine,Standard_Transient)
//=======================================================================
//function : BRepApprox_ApproxLine
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
class Geom_BSplineCurve;
class BRepApprox_ApproxLine;
-DEFINE_STANDARD_HANDLE(BRepApprox_ApproxLine, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(BRepApprox_ApproxLine, Standard_Transient)
-class BRepApprox_ApproxLine : public MMgt_TShared
+class BRepApprox_ApproxLine : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(BRepApprox_ApproxLine,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(BRepApprox_ApproxLine,Standard_Transient)
protected:
#include <Standard_OutOfRange.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(BRepBlend_Line,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(BRepBlend_Line,Standard_Transient)
BRepBlend_Line::BRepBlend_Line ():
tras1(IntSurf_Undecided),tras2(IntSurf_Undecided),
#include <IntSurf_TypeTrans.hxx>
#include <BRepBlend_Extremity.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
class Standard_OutOfRange;
class Blend_Point;
class BRepBlend_Line;
-DEFINE_STANDARD_HANDLE(BRepBlend_Line, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(BRepBlend_Line, Standard_Transient)
-class BRepBlend_Line : public MMgt_TShared
+class BRepBlend_Line : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(BRepBlend_Line,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(BRepBlend_Line,Standard_Transient)
protected:
#include <TopTools_MapOfShape.hxx>
#include <TopTools_SequenceOfShape.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(BRepBuilderAPI_Sewing,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(BRepBuilderAPI_Sewing,Standard_Transient)
//#include <LocalAnalysis_SurfaceContinuity.hxx>
//=======================================================================
#include <Standard_Integer.hxx>
#include <TopTools_DataMapOfShapeListOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_SequenceOfShape.hxx>
#include <TColStd_IndexedMapOfInteger.hxx>
class BRepBuilderAPI_Sewing;
-DEFINE_STANDARD_HANDLE(BRepBuilderAPI_Sewing, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(BRepBuilderAPI_Sewing, Standard_Transient)
//! Provides methods to
//!
//! - output free edges if necessary
//! - output multiple edges if necessary
//! - output the problems if any
-class BRepBuilderAPI_Sewing : public MMgt_TShared
+class BRepBuilderAPI_Sewing : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(BRepBuilderAPI_Sewing,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(BRepBuilderAPI_Sewing,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TopoDS_Shape.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(BRepCheck_Result,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(BRepCheck_Result,Standard_Transient)
//=======================================================================
//function : BRepCheck_Result
#include <Standard_Boolean.hxx>
#include <BRepCheck_DataMapOfShapeListOfStatus.hxx>
#include <BRepCheck_DataMapIteratorOfDataMapOfShapeListOfStatus.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <BRepCheck_ListOfStatus.hxx>
class Standard_NoSuchObject;
class TopoDS_Shape;
class BRepCheck_Result;
-DEFINE_STANDARD_HANDLE(BRepCheck_Result, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(BRepCheck_Result, Standard_Transient)
-class BRepCheck_Result : public MMgt_TShared
+class BRepCheck_Result : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(BRepCheck_Result,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(BRepCheck_Result,Standard_Transient)
protected:
#include <BRepClass3d_SolidClassifier.hxx>
#include <Geom_Curve.hxx>
#include <gp_Pnt.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <NCollection_Map.hxx>
#include <NCollection_Vector.hxx>
#include <Precision.hxx>
//
class BRepCheck_HSC;
-DEFINE_STANDARD_HANDLE(BRepCheck_HSC, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(BRepCheck_HSC, Standard_Transient)
//=======================================================================
//class : BRepCheck_HSC
//purpose :
//=======================================================================
-class BRepCheck_HSC : public MMgt_TShared {
+class BRepCheck_HSC : public Standard_Transient {
public:
//
Standard_EXPORT
return mySC;
};
//
- DEFINE_STANDARD_RTTI_INLINE(BRepCheck_HSC,MMgt_TShared);
+ DEFINE_STANDARD_RTTI_INLINE(BRepCheck_HSC,Standard_Transient);
protected:
BRepClass3d_SolidClassifier mySC;
#include <TopoDS_Vertex.hxx>
#include <TopoDS_Wire.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(BRepFill_LocationLaw,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(BRepFill_LocationLaw,Standard_Transient)
//=======================================================================
//function : Norm
#include <TopTools_HArray1OfShape.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <GeomFill_PipeError.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <Standard_Boolean.hxx>
class BRepFill_LocationLaw;
-DEFINE_STANDARD_HANDLE(BRepFill_LocationLaw, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(BRepFill_LocationLaw, Standard_Transient)
//! Location Law on a Wire.
-class BRepFill_LocationLaw : public MMgt_TShared
+class BRepFill_LocationLaw : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(BRepFill_LocationLaw,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(BRepFill_LocationLaw,Standard_Transient)
protected:
#include <TopTools_SequenceOfShape.hxx>
#include <stdio.h>
-IMPLEMENT_STANDARD_RTTIEXT(BRepFill_PipeShell,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(BRepFill_PipeShell,Standard_Transient)
//Specification Guide
#ifdef DRAW
#include <GeomFill_Trihedron.hxx>
#include <BRepFill_TransitionStyle.hxx>
#include <GeomFill_PipeError.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <BRepFill_TypeOfContact.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_SequenceOfShape.hxx>
class BRepFill_PipeShell;
-DEFINE_STANDARD_HANDLE(BRepFill_PipeShell, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(BRepFill_PipeShell, Standard_Transient)
//! Computes a topological shell using some wires
//! (spines and profiles) and diplacement option
//! Perform general sweeping construction
-class BRepFill_PipeShell : public MMgt_TShared
+class BRepFill_PipeShell : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(BRepFill_PipeShell,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(BRepFill_PipeShell,Standard_Transient)
protected:
#include <TopoDS_Vertex.hxx>
#include <TopoDS_Wire.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(BRepFill_SectionLaw,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(BRepFill_SectionLaw,Standard_Transient)
//=======================================================================
//function : NbLaw
#include <TopTools_DataMapOfShapeInteger.hxx>
#include <Standard_Boolean.hxx>
#include <BRepTools_WireExplorer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
#include <GeomAbs_Shape.hxx>
#include <Standard_Real.hxx>
class TopoDS_Edge;
class BRepFill_SectionLaw;
-DEFINE_STANDARD_HANDLE(BRepFill_SectionLaw, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(BRepFill_SectionLaw, Standard_Transient)
//! Build Section Law, with an Vertex, or an Wire
-class BRepFill_SectionLaw : public MMgt_TShared
+class BRepFill_SectionLaw : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(BRepFill_SectionLaw,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(BRepFill_SectionLaw,Standard_Transient)
protected:
#include <Poly_PolygonOnTriangulation.hxx>
#include <Poly_Triangulation.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(BRepTools_Modification,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(BRepTools_Modification,Standard_Transient)
Standard_Boolean BRepTools_Modification::NewTriangulation(const TopoDS_Face&, Handle(Poly_Triangulation)&)
{
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Real.hxx>
#include <GeomAbs_Shape.hxx>
class BRepTools_Modification;
-DEFINE_STANDARD_HANDLE(BRepTools_Modification, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(BRepTools_Modification, Standard_Transient)
//! Defines geometric modifications to a shape, i.e.
//! changes to faces, edges and vertices.
-class BRepTools_Modification : public MMgt_TShared
+class BRepTools_Modification : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(BRepTools_Modification,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(BRepTools_Modification,Standard_Transient)
protected:
#include <TopoDS_Shell.hxx>
#include <TopoDS_Solid.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(BRepTools_ReShape,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(BRepTools_ReShape,Standard_Transient)
namespace
{
#include <TopTools_MapOfShape.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TopAbs_ShapeEnum.hxx>
class TopoDS_Shape;
#endif
class BRepTools_ReShape;
-DEFINE_STANDARD_HANDLE(BRepTools_ReShape, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(BRepTools_ReShape, Standard_Transient)
//! Rebuilds a Shape by making pre-defined substitutions on some
//! of its components
//! contain one or more of these individual shapes
//!
//! Supports the 'BRepTools_History' history by method 'History'.
-class BRepTools_ReShape : public MMgt_TShared
+class BRepTools_ReShape : public Standard_Transient
{
public:
//! Returns an empty Reshape
//! Returns the history of the substituted shapes.
Standard_EXPORT Handle(BRepTools_History) History() const;
- DEFINE_STANDARD_RTTIEXT(BRepTools_ReShape,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(BRepTools_ReShape,Standard_Transient)
protected:
//! The kinds of the replacements.
#include <TCollection_ExtendedString.hxx>
#include <TDF_Attribute.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(BinMDF_ADriver,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(BinMDF_ADriver,Standard_Transient)
//=======================================================================
//function : BinMDF_ADriver
#include <Standard_Type.hxx>
#include <TCollection_AsciiString.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
class BinMDF_ADriver;
-DEFINE_STANDARD_HANDLE(BinMDF_ADriver, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(BinMDF_ADriver, Standard_Transient)
//! Attribute Storage/Retrieval Driver.
-class BinMDF_ADriver : public MMgt_TShared
+class BinMDF_ADriver : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(BinMDF_ADriver,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(BinMDF_ADriver,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(BinMDF_ADriverTable,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(BinMDF_ADriverTable,Standard_Transient)
//=======================================================================
//function : BinMDF_ADriverTable
#include <BinMDF_TypeADriverMap.hxx>
#include <BinMDF_TypeIdMap.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Type.hxx>
#include <Standard_Integer.hxx>
#include <TColStd_IndexedMapOfTransient.hxx>
class BinMDF_ADriverTable;
-DEFINE_STANDARD_HANDLE(BinMDF_ADriverTable, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(BinMDF_ADriverTable, Standard_Transient)
//! A driver table is an object building links between
//! object types and object drivers. In the
//! translation process, a driver table is asked to
//! give a translation driver for each current object
//! to be translated.
-class BinMDF_ADriverTable : public MMgt_TShared
+class BinMDF_ADriverTable : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(BinMDF_ADriverTable,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(BinMDF_ADriverTable,Standard_Transient)
protected:
Handle(ChFiDS_SecHArray1) res;
for (itel.Initialize(myListStripe);itel.More(); itel.Next(), i++) {
if(i == IC){
- Handle(MMgt_TShared) bid = itel.Value()->SetOfSurfData()->Value(IS)->Simul();
+ Handle(Standard_Transient) bid = itel.Value()->SetOfSurfData()->Value(IS)->Simul();
res = Handle(ChFiDS_SecHArray1)::DownCast(bid);
return res;
}
Handle(ChFiDS_SecHArray1) res;
for (itel.Initialize(myListStripe);itel.More(); itel.Next(), i++) {
if(i == IC){
- Handle(MMgt_TShared) bid = itel.Value()->SetOfSurfData()->Value(IS)->Simul();
+ Handle(Standard_Transient) bid = itel.Value()->SetOfSurfData()->Value(IS)->Simul();
res = Handle(ChFiDS_SecHArray1)::DownCast(bid);
return res;
}
#include <TopoDS_Edge.hxx>
#include <TopoDS_Vertex.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(ChFiDS_Spine,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(ChFiDS_Spine,Standard_Transient)
//=======================================================================
//function : ChFiDS_Spine
#include <gp_Pnt.hxx>
#include <gp_Vec.hxx>
#include <ChFiDS_ErrorStatus.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <GeomAbs_CurveType.hxx>
class TopoDS_Edge;
class ChFiDS_HElSpine;
#endif
class ChFiDS_Spine;
-DEFINE_STANDARD_HANDLE(ChFiDS_Spine, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(ChFiDS_Spine, Standard_Transient)
//! Contains information necessary for construction of
//! a 3D fillet or chamfer:
//! the approach and double the Spine of line C2 with
//! the known consequences for management of
//! interactions between KPart Blend in Fil3d.
-class ChFiDS_Spine : public MMgt_TShared
+class ChFiDS_Spine : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(ChFiDS_Spine,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(ChFiDS_Spine,Standard_Transient)
protected:
#include <Geom2d_Curve.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(ChFiDS_Stripe,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(ChFiDS_Stripe,Standard_Transient)
ChFiDS_Stripe::ChFiDS_Stripe ():
begfilled(/*Standard_False*/0), // eap, Apr 29 2002, occ293
#include <ChFiDS_HData.hxx>
#include <Standard_Integer.hxx>
#include <TopAbs_Orientation.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
class ChFiDS_Spine;
class Geom2d_Curve;
class ChFiDS_Stripe;
-DEFINE_STANDARD_HANDLE(ChFiDS_Stripe, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(ChFiDS_Stripe, Standard_Transient)
//! Data characterising a band of fillet.
-class ChFiDS_Stripe : public MMgt_TShared
+class ChFiDS_Stripe : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(ChFiDS_Stripe,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(ChFiDS_Stripe,Standard_Transient)
protected:
#include <ChFiDS_FaceInterference.hxx>
#include <ChFiDS_SurfData.hxx>
#include <gp_Pnt2d.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(ChFiDS_SurfData,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(ChFiDS_SurfData,Standard_Transient)
ChFiDS_SurfData::ChFiDS_SurfData () :
indexOfS1(0),indexOfS2(0),indexOfConge(0),
//purpose :
//=======================================================================
-Handle(MMgt_TShared) ChFiDS_SurfData::Simul() const
+Handle(Standard_Transient) ChFiDS_SurfData::Simul() const
{
return simul;
}
//purpose :
//=======================================================================
-void ChFiDS_SurfData::SetSimul(const Handle(MMgt_TShared)& S)
+void ChFiDS_SurfData::SetSimul(const Handle(Standard_Transient)& S)
{
simul = S;
}
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
#include <TopAbs_Orientation.hxx>
-#include <MMgt_TShared.hxx>
-class MMgt_TShared;
+#include <Standard_Transient.hxx>
+
class ChFiDS_FaceInterference;
class ChFiDS_CommonPoint;
class gp_Pnt2d;
class ChFiDS_SurfData;
-DEFINE_STANDARD_HANDLE(ChFiDS_SurfData, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(ChFiDS_SurfData, Standard_Transient)
//! data structure for all information related to the
//! fillet and to 2 faces vis a vis
-class ChFiDS_SurfData : public MMgt_TShared
+class ChFiDS_SurfData : public Standard_Transient
{
public:
Standard_EXPORT void LastExtensionValue (const Standard_Real Extend);
- Standard_EXPORT Handle(MMgt_TShared) Simul() const;
+ Standard_EXPORT Handle(Standard_Transient) Simul() const;
- Standard_EXPORT void SetSimul (const Handle(MMgt_TShared)& S);
+ Standard_EXPORT void SetSimul (const Handle(Standard_Transient)& S);
Standard_EXPORT void ResetSimul();
- DEFINE_STANDARD_RTTIEXT(ChFiDS_SurfData,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(ChFiDS_SurfData,Standard_Transient)
protected:
Standard_Real ulspine;
Standard_Real myfirstextend;
Standard_Real mylastextend;
- Handle(MMgt_TShared) simul;
+ Handle(Standard_Transient) simul;
Standard_Integer indexOfS1;
Standard_Integer indexOfC1;
Standard_Integer indexOfS2;
#include <Standard_Integer.hxx>
#include <IntSurf_PathPoint.hxx>
#include <gp_Vec.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <IntSurf_Allocator.hxx>
class IntSurf_LineOn2S;
class Standard_OutOfRange;
class Contap_TheIWLineOfTheIWalking;
-DEFINE_STANDARD_HANDLE(Contap_TheIWLineOfTheIWalking, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Contap_TheIWLineOfTheIWalking, Standard_Transient)
-class Contap_TheIWLineOfTheIWalking : public MMgt_TShared
+class Contap_TheIWLineOfTheIWalking : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTI_INLINE(Contap_TheIWLineOfTheIWalking,MMgt_TShared)
+ DEFINE_STANDARD_RTTI_INLINE(Contap_TheIWLineOfTheIWalking,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TopoDS_Edge.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(DBRep_Edge,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(DBRep_Edge,Standard_Transient)
//=======================================================================
//function : DBRep_Edge
#include <TopoDS_Edge.hxx>
#include <Draw_Color.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TopoDS_Edge;
class Draw_Color;
class DBRep_Edge;
-DEFINE_STANDARD_HANDLE(DBRep_Edge, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(DBRep_Edge, Standard_Transient)
//! Display of an edge. Edge + color.
-class DBRep_Edge : public MMgt_TShared
+class DBRep_Edge : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(DBRep_Edge,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(DBRep_Edge,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TopoDS_Face.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(DBRep_Face,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(DBRep_Face,Standard_Transient)
//=======================================================================
//function : DBRep_Face
#include <Draw_Color.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <TColStd_Array1OfReal.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
#include <GeomAbs_IsoType.hxx>
#include <Standard_Real.hxx>
class DBRep_Face;
-DEFINE_STANDARD_HANDLE(DBRep_Face, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(DBRep_Face, Standard_Transient)
//! Display of a face. Face + Array of iso + color.
-class DBRep_Face : public MMgt_TShared
+class DBRep_Face : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(DBRep_Face,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(DBRep_Face,Standard_Transient)
protected:
#include <TDF_Data.hxx>
#include <TDF_Delta.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(DDF_Transaction,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(DDF_Transaction,Standard_Transient)
//=======================================================================
//function : DDF_Transaction
#include <Standard_Type.hxx>
#include <TDF_Transaction.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
class Standard_DomainError;
class DDF_Transaction;
-DEFINE_STANDARD_HANDLE(DDF_Transaction, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(DDF_Transaction, Standard_Transient)
//! This class encapsulates TDF_Transaction.
-class DDF_Transaction : public MMgt_TShared
+class DDF_Transaction : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(DDF_Transaction,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(DDF_Transaction,Standard_Transient)
protected:
#include <TopoDS_Compound.hxx>
#include <TopoDS_Shape.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(DDataStd_DrawDriver,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(DDataStd_DrawDriver,Standard_Transient)
// attribut affichable
// drawable object
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Draw_ColorKind.hxx>
#include <Standard_Boolean.hxx>
class Draw_Drawable3D;
class DDataStd_DrawDriver;
-DEFINE_STANDARD_HANDLE(DDataStd_DrawDriver, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(DDataStd_DrawDriver, Standard_Transient)
//! Root class of drivers to build draw variables from TDF_Label.
//! Priority rule to display standard attributes is :
//! * 3 Datum (Point,Axis,Plane)
//! * 4 Geometry
//! * 5 NamedShape
-class DDataStd_DrawDriver : public MMgt_TShared
+class DDataStd_DrawDriver : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(DDataStd_DrawDriver,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(DDataStd_DrawDriver,Standard_Transient)
protected:
#include <Draw_Drawable3D.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Draw_Drawable3D,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Draw_Drawable3D,Standard_Transient)
//=======================================================================
//function : Draw_Drawable3D
#include <Standard_Real.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_CString.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_OStream.hxx>
#include <Draw_Interpretor.hxx>
class Draw_Display;
class Draw_Drawable3D;
-DEFINE_STANDARD_HANDLE(Draw_Drawable3D, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Draw_Drawable3D, Standard_Transient)
-class Draw_Drawable3D : public MMgt_TShared
+class Draw_Drawable3D : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Draw_Drawable3D,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Draw_Drawable3D,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TCollection_AsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Expr_GeneralExpression,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Expr_GeneralExpression,Standard_Transient)
Standard_Boolean Expr_GeneralExpression::IsShareable() const
{
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Real.hxx>
class Expr_GeneralExpression;
-DEFINE_STANDARD_HANDLE(Expr_GeneralExpression, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Expr_GeneralExpression, Standard_Transient)
//! Defines the general purposes of any expression.
-class Expr_GeneralExpression : public MMgt_TShared
+class Expr_GeneralExpression : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Expr_GeneralExpression,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Expr_GeneralExpression,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TCollection_AsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Expr_GeneralFunction,MMgt_TShared)
\ No newline at end of file
+IMPLEMENT_STANDARD_RTTIEXT(Expr_GeneralFunction,Standard_Transient)
\ No newline at end of file
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
#include <Expr_Array1OfNamedUnknown.hxx>
class Expr_GeneralFunction;
-DEFINE_STANDARD_HANDLE(Expr_GeneralFunction, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Expr_GeneralFunction, Standard_Transient)
//! Defines the general purposes of any function.
-class Expr_GeneralFunction : public MMgt_TShared
+class Expr_GeneralFunction : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Expr_GeneralFunction,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Expr_GeneralFunction,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TCollection_AsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Expr_GeneralRelation,MMgt_TShared)
\ No newline at end of file
+IMPLEMENT_STANDARD_RTTIEXT(Expr_GeneralRelation,Standard_Transient)
\ No newline at end of file
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
class Standard_OutOfRange;
class Expr_GeneralRelation;
-DEFINE_STANDARD_HANDLE(Expr_GeneralRelation, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Expr_GeneralRelation, Standard_Transient)
//! Defines the general purposes of any relation between
//! expressions.
-class Expr_GeneralRelation : public MMgt_TShared
+class Expr_GeneralRelation : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Expr_GeneralRelation,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Expr_GeneralRelation,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TCollection_AsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(ExprIntrp_Generator,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(ExprIntrp_Generator,Standard_Transient)
//#include <ExprIntrp_yaccanal.hxx>
Standard_EXPORT ExprIntrp_Analysis ExprIntrp_Recept;
#include <ExprIntrp_SequenceOfNamedFunction.hxx>
#include <ExprIntrp_SequenceOfNamedExpression.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class Expr_NamedFunction;
class Expr_NamedExpression;
class TCollection_AsciiString;
class ExprIntrp_Generator;
-DEFINE_STANDARD_HANDLE(ExprIntrp_Generator, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(ExprIntrp_Generator, Standard_Transient)
//! Implements general services for interpretation of
//! expressions.
-class ExprIntrp_Generator : public MMgt_TShared
+class ExprIntrp_Generator : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(ExprIntrp_Generator,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(ExprIntrp_Generator,Standard_Transient)
protected:
#include <Standard_DimensionError.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(FEmTool_Curve,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(FEmTool_Curve,Standard_Transient)
//=======================================================================
//function : FEmTool_Curve
#include <TColStd_Array1OfInteger.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <Standard_Real.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TColStd_Array2OfReal.hxx>
class PLib_Base;
class Standard_DimensionError;
class FEmTool_Curve;
-DEFINE_STANDARD_HANDLE(FEmTool_Curve, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(FEmTool_Curve, Standard_Transient)
//! Curve defined by Polynomial Elements.
-class FEmTool_Curve : public MMgt_TShared
+class FEmTool_Curve : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(FEmTool_Curve,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(FEmTool_Curve,Standard_Transient)
protected:
#include <Standard_NotImplemented.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(FEmTool_ElementaryCriterion,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(FEmTool_ElementaryCriterion,Standard_Transient)
void FEmTool_ElementaryCriterion::Set(const Handle(TColStd_HArray2OfReal)& Coeff)
{
#include <TColStd_HArray2OfReal.hxx>
#include <Standard_Real.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TColStd_HArray2OfInteger.hxx>
#include <Standard_Integer.hxx>
#include <math_Vector.hxx>
class FEmTool_ElementaryCriterion;
-DEFINE_STANDARD_HANDLE(FEmTool_ElementaryCriterion, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(FEmTool_ElementaryCriterion, Standard_Transient)
//! defined J Criteria to used in minimisation
-class FEmTool_ElementaryCriterion : public MMgt_TShared
+class FEmTool_ElementaryCriterion : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(FEmTool_ElementaryCriterion,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(FEmTool_ElementaryCriterion,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <StdFail_NotDone.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(FEmTool_SparseMatrix,MMgt_TShared)
\ No newline at end of file
+IMPLEMENT_STANDARD_RTTIEXT(FEmTool_SparseMatrix,Standard_Transient)
\ No newline at end of file
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
class FEmTool_SparseMatrix;
-DEFINE_STANDARD_HANDLE(FEmTool_SparseMatrix, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(FEmTool_SparseMatrix, Standard_Transient)
//! Sparse Matrix definition
-class FEmTool_SparseMatrix : public MMgt_TShared
+class FEmTool_SparseMatrix : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(FEmTool_SparseMatrix,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(FEmTool_SparseMatrix,Standard_Transient)
protected:
#include <ft2build.h>
#include FT_FREETYPE_H
-IMPLEMENT_STANDARD_RTTIEXT(Font_FontMgr,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Font_FontMgr,Standard_Transient)
struct Font_FontMgr_FontAliasMapNode
{
#include <Standard_Type.hxx>
#include <Font_NListOfSystemFont.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TColStd_SequenceOfHAsciiString.hxx>
#include <Font_FontAspect.hxx>
#include <Standard_Integer.hxx>
class Font_FontMgr;
-DEFINE_STANDARD_HANDLE(Font_FontMgr, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Font_FontMgr, Standard_Transient)
//! Collects and provides information about available fonts in system.
-class Font_FontMgr : public MMgt_TShared
+class Font_FontMgr : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Font_FontMgr,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Font_FontMgr,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Font_SystemFont,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Font_SystemFont,Standard_Transient)
Font_SystemFont::Font_SystemFont():
MyFontName(),
#include <Font_FontAspect.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class Font_SystemFont;
-DEFINE_STANDARD_HANDLE(Font_SystemFont, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Font_SystemFont, Standard_Transient)
//! Structure for store of Font System Information
-class Font_SystemFont : public MMgt_TShared
+class Font_SystemFont : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Font_SystemFont,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Font_SystemFont,Standard_Transient)
protected:
#include <Standard_NotImplemented.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(GccInt_Bisec,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(GccInt_Bisec,Standard_Transient)
gp_Circ2d GccInt_Bisec::
Circle() const {
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <GccInt_IType.hxx>
class Standard_DomainError;
class gp_Pnt2d;
class GccInt_Bisec;
-DEFINE_STANDARD_HANDLE(GccInt_Bisec, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(GccInt_Bisec, Standard_Transient)
//! The deferred class GccInt_Bisec is the root class for
//! elementary bisecting loci between two simple geometric
//! The GccAna package provides numerous algorithms for
//! computing the bisecting loci between circles, lines or
//! points, whose solutions are these types of elementary bisecting locus.
-class GccInt_Bisec : public MMgt_TShared
+class GccInt_Bisec : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(GccInt_Bisec,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(GccInt_Bisec,Standard_Transient)
protected:
#include <Standard_ConstructionError.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Geom_Geometry,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Geom_Geometry,Standard_Transient)
typedef Geom_Geometry Geometry;
typedef gp_Pnt Pnt;
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Real.hxx>
class Standard_ConstructionError;
class gp_Pnt;
class Geom_Geometry;
-DEFINE_STANDARD_HANDLE(Geom_Geometry, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Geom_Geometry, Standard_Transient)
//! The abstract class Geometry for 3D space is the root
//! class of all geometric objects from the Geom
//! abstract method Transform which is defined for each
//! concrete type of derived object. All other
//! transformations are implemented using the Transform method.
-class Geom_Geometry : public MMgt_TShared
+class Geom_Geometry : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Geom_Geometry,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Geom_Geometry,Standard_Transient)
protected:
#include <TColStd_HArray1OfReal.hxx>
#include <TColStd_HArray2OfInteger.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Geom_OsculatingSurface,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Geom_OsculatingSurface,Standard_Transient)
//=======================================================================
//function : Geom_OffsetOsculatingSurface
class Geom_OsculatingSurface;
-DEFINE_STANDARD_HANDLE(Geom_OsculatingSurface, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Geom_OsculatingSurface, Standard_Transient)
-class Geom_OsculatingSurface : public MMgt_TShared
+class Geom_OsculatingSurface : public Standard_Transient
{
public:
Standard_EXPORT Standard_Boolean VOscSurf (const Standard_Real U, const Standard_Real V, Standard_Boolean& t, Handle(Geom_BSplineSurface)& L) const;
- DEFINE_STANDARD_RTTIEXT(Geom_OsculatingSurface,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Geom_OsculatingSurface,Standard_Transient)
protected:
#include <Standard_ConstructionError.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Geom2d_Geometry,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Geom2d_Geometry,Standard_Transient)
typedef Geom2d_Geometry Geometry;
typedef gp_Ax2d Ax2d;
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Real.hxx>
class Standard_ConstructionError;
class gp_Pnt2d;
class Geom2d_Geometry;
-DEFINE_STANDARD_HANDLE(Geom2d_Geometry, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Geom2d_Geometry, Standard_Transient)
//! The general abstract class Geometry in 2D space describes
//! abstract method Transform which is defined for each
//! concrete type of derived object. All other
//! transformations are implemented using the Transform method.
-class Geom2d_Geometry : public MMgt_TShared
+class Geom2d_Geometry : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Geom2d_Geometry,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Geom2d_Geometry,Standard_Transient)
protected:
#include <Standard_OutOfRange.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Geom2d_Transformation,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Geom2d_Transformation,Standard_Transient)
typedef Geom2d_Transformation Transformation;
typedef gp_Ax2d Ax2d;
#include <Standard_Type.hxx>
#include <gp_Trsf2d.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Real.hxx>
#include <Standard_Boolean.hxx>
#include <gp_TrsfForm.hxx>
class Geom2d_Transformation;
-DEFINE_STANDARD_HANDLE(Geom2d_Transformation, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Geom2d_Transformation, Standard_Transient)
//! The class Transformation allows to create Translation,
//! - Geom2d_Transformation transformations are
//! used in a context where they can be shared by
//! several objects contained inside a common data structure.
-class Geom2d_Transformation : public MMgt_TShared
+class Geom2d_Transformation : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Geom2d_Transformation,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Geom2d_Transformation,Standard_Transient)
protected:
#include <gp_Vec.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(GeomFill_Boundary,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(GeomFill_Boundary,Standard_Transient)
//=======================================================================
//function : GeomFill_Boundary
#include <Standard_Type.hxx>
#include <Standard_Real.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
class gp_Pnt;
class gp_Vec;
class GeomFill_Boundary;
-DEFINE_STANDARD_HANDLE(GeomFill_Boundary, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(GeomFill_Boundary, Standard_Transient)
//! Root class to define a boundary which will form part of a
//! contour around a gap requiring filling.
//! - GeomFill_BoundWithSurf to define a boundary attached to a surface.
//! These objects are used to define the boundaries for a
//! GeomFill_ConstrainedFilling framework.
-class GeomFill_Boundary : public MMgt_TShared
+class GeomFill_Boundary : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(GeomFill_Boundary,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(GeomFill_Boundary,Standard_Transient)
protected:
#include <Law_Linear.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(GeomFill_CoonsAlgPatch,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(GeomFill_CoonsAlgPatch,Standard_Transient)
//=======================================================================
//function : GeomFill_CoonsAlgPatch
#include <Standard_Type.hxx>
#include <gp_Pnt.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
class GeomFill_Boundary;
class GeomFill_CoonsAlgPatch;
-DEFINE_STANDARD_HANDLE(GeomFill_CoonsAlgPatch, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(GeomFill_CoonsAlgPatch, Standard_Transient)
//! Provides evaluation methods on an algorithmic
//! patch (based on 4 Curves) defined by its boundaries and blending
//! functions.
-class GeomFill_CoonsAlgPatch : public MMgt_TShared
+class GeomFill_CoonsAlgPatch : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(GeomFill_CoonsAlgPatch,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(GeomFill_CoonsAlgPatch,Standard_Transient)
protected:
#include <GeomFill_Line.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(GeomFill_Line,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(GeomFill_Line,Standard_Transient)
//=======================================================================
//function : GeomFill_Line
#include <Standard_Type.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class GeomFill_Line;
-DEFINE_STANDARD_HANDLE(GeomFill_Line, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(GeomFill_Line, Standard_Transient)
//! class for instantiation of AppBlend
-class GeomFill_Line : public MMgt_TShared
+class GeomFill_Line : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(GeomFill_Line,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(GeomFill_Line,Standard_Transient)
protected:
#include <Standard_OutOfRange.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(GeomFill_LocationLaw,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(GeomFill_LocationLaw,Standard_Transient)
Standard_Boolean GeomFill_LocationLaw::D1(const Standard_Real, gp_Mat&, gp_Vec&,gp_Mat&, gp_Vec&,TColgp_Array1OfPnt2d&,TColgp_Array1OfVec2d&)
{
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Real.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
class GeomFill_LocationLaw;
-DEFINE_STANDARD_HANDLE(GeomFill_LocationLaw, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(GeomFill_LocationLaw, Standard_Transient)
//! To define location law in Sweeping location is --
//! defined by an Matrix M and an Vector V, and
//! transform an point P in MP+V.
-class GeomFill_LocationLaw : public MMgt_TShared
+class GeomFill_LocationLaw : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(GeomFill_LocationLaw,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(GeomFill_LocationLaw,Standard_Transient)
protected:
#include <Standard_OutOfRange.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(GeomFill_SectionLaw,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(GeomFill_SectionLaw,Standard_Transient)
Standard_Boolean GeomFill_SectionLaw::D1(const Standard_Real,TColgp_Array1OfPnt&,TColgp_Array1OfVec&,TColStd_Array1OfReal&,TColStd_Array1OfReal& )
{
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Real.hxx>
#include <TColgp_Array1OfPnt.hxx>
class GeomFill_SectionLaw;
-DEFINE_STANDARD_HANDLE(GeomFill_SectionLaw, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(GeomFill_SectionLaw, Standard_Transient)
//! To define section law in sweeping
-class GeomFill_SectionLaw : public MMgt_TShared
+class GeomFill_SectionLaw : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(GeomFill_SectionLaw,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(GeomFill_SectionLaw,Standard_Transient)
protected:
#include <Law_BSpline.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(GeomFill_TgtField,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(GeomFill_TgtField,Standard_Transient)
//=======================================================================
//function : IsScalable
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Real.hxx>
class Law_BSpline;
class GeomFill_TgtField;
-DEFINE_STANDARD_HANDLE(GeomFill_TgtField, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(GeomFill_TgtField, Standard_Transient)
//! Root class defining the methods we need to make an
//! algorithmic tangents field.
-class GeomFill_TgtField : public MMgt_TShared
+class GeomFill_TgtField : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(GeomFill_TgtField,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(GeomFill_TgtField,Standard_Transient)
protected:
#include <Standard_OutOfRange.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(GeomFill_TrihedronLaw,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(GeomFill_TrihedronLaw,Standard_Transient)
void GeomFill_TrihedronLaw::SetCurve(const Handle(Adaptor3d_HCurve)& C)
{
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <GeomFill_PipeError.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Real.hxx>
class GeomFill_TrihedronLaw;
-DEFINE_STANDARD_HANDLE(GeomFill_TrihedronLaw, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(GeomFill_TrihedronLaw, Standard_Transient)
//! To define Trihedron along one Curve
-class GeomFill_TrihedronLaw : public MMgt_TShared
+class GeomFill_TrihedronLaw : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(GeomFill_TrihedronLaw,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(GeomFill_TrihedronLaw,Standard_Transient)
protected:
#include <Standard_ConstructionError.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(GeomPlate_CurveConstraint,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(GeomPlate_CurveConstraint,Standard_Transient)
//---------------------------------------------------------
// Constructeur vide
#include <Standard_Boolean.hxx>
#include <GeomLProp_SLProps.hxx>
#include <Standard_Real.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class Adaptor3d_HCurveOnSurface;
class Adaptor3d_HCurve;
class Geom2d_Curve;
class GeomPlate_CurveConstraint;
-DEFINE_STANDARD_HANDLE(GeomPlate_CurveConstraint, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(GeomPlate_CurveConstraint, Standard_Transient)
//! Defines curves as constraints to be used to deform a surface.
-class GeomPlate_CurveConstraint : public MMgt_TShared
+class GeomPlate_CurveConstraint : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(GeomPlate_CurveConstraint,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(GeomPlate_CurveConstraint,Standard_Transient)
protected:
#include <Standard_ConstructionError.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(GeomPlate_PointConstraint,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(GeomPlate_PointConstraint,Standard_Transient)
//---------------------------------------------------------
// Constructeurs avec un point
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class Geom_Surface;
class Standard_ConstructionError;
class gp_Pnt;
class GeomPlate_PointConstraint;
-DEFINE_STANDARD_HANDLE(GeomPlate_PointConstraint, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(GeomPlate_PointConstraint, Standard_Transient)
//! Defines points as constraints to be used to deform a surface.
-class GeomPlate_PointConstraint : public MMgt_TShared
+class GeomPlate_PointConstraint : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(GeomPlate_PointConstraint,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(GeomPlate_PointConstraint,Standard_Transient)
protected:
#include <GeomTools_UndefinedTypeHandler.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(GeomTools_UndefinedTypeHandler,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(GeomTools_UndefinedTypeHandler,Standard_Transient)
GeomTools_UndefinedTypeHandler::GeomTools_UndefinedTypeHandler()
{
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_OStream.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_IStream.hxx>
class GeomTools_UndefinedTypeHandler;
-DEFINE_STANDARD_HANDLE(GeomTools_UndefinedTypeHandler, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(GeomTools_UndefinedTypeHandler, Standard_Transient)
-class GeomTools_UndefinedTypeHandler : public MMgt_TShared
+class GeomTools_UndefinedTypeHandler : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(GeomTools_UndefinedTypeHandler,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(GeomTools_UndefinedTypeHandler,Standard_Transient)
protected:
#include <stdio.h>
#include <stdlib.h>
-IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ArrayOfPrimitives,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ArrayOfPrimitives,Standard_Transient)
Graphic3d_ArrayOfPrimitives::Graphic3d_ArrayOfPrimitives (const Graphic3d_TypeOfPrimitiveArray theType,
const Standard_Integer theMaxVertexs,
#include <Graphic3d_TypeOfPrimitiveArray.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Byte.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Real.hxx>
#include <Standard_ShortReal.hxx>
class Graphic3d_ArrayOfPrimitives;
-DEFINE_STANDARD_HANDLE(Graphic3d_ArrayOfPrimitives, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Graphic3d_ArrayOfPrimitives, Standard_Transient)
//! This class furnish services to defined and fill an
//! array of primitives compatible with the use of
//! 3) Enable to change dynamically the components of the primitive
//! (vertice,normal,color,texture coordinates).
//! 4) Add true triangle and quadrangle strips or fans capabilities.
-class Graphic3d_ArrayOfPrimitives : public MMgt_TShared
+class Graphic3d_ArrayOfPrimitives : public Standard_Transient
{
public:
friend class Graphic3d_Group;
- DEFINE_STANDARD_RTTIEXT(Graphic3d_ArrayOfPrimitives,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Graphic3d_ArrayOfPrimitives,Standard_Transient)
protected:
#include <Graphic3d_ShaderProgram.hxx>
#include <Font_FontAspect.hxx>
#include <Font_NameOfFont.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Real.hxx>
#include <Graphic3d_DataStructureManager.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_DataStructureManager,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_DataStructureManager,Standard_Transient)
//-Aliases
//-Global data definitions
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class Graphic3d_DataStructureManager;
-DEFINE_STANDARD_HANDLE(Graphic3d_DataStructureManager, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Graphic3d_DataStructureManager, Standard_Transient)
//! This class allows the definition of a manager to
//! which the graphic objects are associated.
//! It allows them to be globally manipulated.
//! It defines the global attributes.
-class Graphic3d_DataStructureManager : public MMgt_TShared
+class Graphic3d_DataStructureManager : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Graphic3d_DataStructureManager,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Graphic3d_DataStructureManager,Standard_Transient)
protected:
#include <Graphic3d_GraphicDriver.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_GraphicDriver,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_GraphicDriver,Standard_Transient)
// =======================================================================
// function : Graphic3d_GraphicDriver
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Graphic3d_CView.hxx>
#include <Graphic3d_CStructure.hxx>
#include <Aspect_GradientFillMethod.hxx>
class Quantity_Color;
class TCollection_AsciiString;
-DEFINE_STANDARD_HANDLE(Graphic3d_GraphicDriver, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Graphic3d_GraphicDriver, Standard_Transient)
//! This class allows the definition of a graphic driver
//! for 3d interface (currently only OpenGl driver is used).
-class Graphic3d_GraphicDriver : public MMgt_TShared
+class Graphic3d_GraphicDriver : public Standard_Transient
{
public:
//! Frees the identifier of a structure.
Standard_EXPORT void RemoveIdentification(const Standard_Integer theId);
- DEFINE_STANDARD_RTTIEXT(Graphic3d_GraphicDriver,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Graphic3d_GraphicDriver,Standard_Transient)
protected:
#include <TCollection_AsciiString.hxx>
#include <TCollection_ExtendedString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_Group,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_Group,Standard_Transient)
// =======================================================================
// function : Graphic3d_Group
#include <Graphic3d_AspectFillArea3d.hxx>
#include <Graphic3d_AspectText3d.hxx>
#include <Graphic3d_AspectMarker3d.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Real.hxx>
#include <Standard_CString.hxx>
#include <Graphic3d_Vertex.hxx>
//! with aspects and primitives and choose the group usage model beforehand out of application needs.
//! Note that some Graphic3d_Group class virtual methods contain only base implementation
//! that is extended by the descendant class in OpenGl package.
-class Graphic3d_Group : public MMgt_TShared
+class Graphic3d_Group : public Standard_Transient
{
friend class Graphic3d_Structure;
- DEFINE_STANDARD_RTTIEXT(Graphic3d_Group,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Graphic3d_Group,Standard_Transient)
public:
};
-DEFINE_STANDARD_HANDLE(Graphic3d_Group, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Graphic3d_Group, Standard_Transient)
#endif // _Graphic3d_Group_HeaderFile
#include <stdio.h>
-IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_Structure,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_Structure,Standard_Transient)
//=============================================================================
//function : Graphic3d_Structure
#include <Graphic3d_IndexedMapOfAddress.hxx>
#include <Standard_Address.hxx>
#include <Graphic3d_TypeOfStructure.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
#include <Graphic3d_ZLayerId.hxx>
class Graphic3d_Structure;
-DEFINE_STANDARD_HANDLE(Graphic3d_Structure, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Graphic3d_Structure, Standard_Transient)
//! This class allows the definition a graphic object.
//! This graphic structure can be displayed,
//! Keywords: Structure, StructureManager, Display, Erase, Highlight,
//! UnHighlight, Visible, Priority, Selectable, Visible,
//! Visual, Connection, Ancestors, Descendants, Transformation
-class Graphic3d_Structure : public MMgt_TShared
+class Graphic3d_Structure : public Standard_Transient
{
public:
friend class Graphic3d_Group;
- DEFINE_STANDARD_RTTIEXT(Graphic3d_Structure,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Graphic3d_Structure,Standard_Transient)
protected:
#include <Graphic3d_GraphicDriver.hxx>
#include <Graphic3d_Structure.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_StructureManager,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_StructureManager,Standard_Transient)
#include <Graphic3d_MapIteratorOfMapOfStructure.hxx>
#include <Graphic3d_CView.hxx>
#include <Graphic3d_ViewAffinity.hxx>
#include <Graphic3d_ZLayerId.hxx>
#include <Graphic3d_ZLayerSettings.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <NCollection_IndexedMap.hxx>
#include <Standard.hxx>
#include <Standard_Boolean.hxx>
class Standard_Transient;
class Graphic3d_StructureManager;
-DEFINE_STANDARD_HANDLE(Graphic3d_StructureManager, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Graphic3d_StructureManager, Standard_Transient)
//! This class allows the definition of a manager to
//! which the graphic objects are associated.
//! It defines the global attributes.
//! Keywords: Structure, Structure Manager, Update Mode,
//! Destroy, Highlight, Visible
-class Graphic3d_StructureManager : public MMgt_TShared
+class Graphic3d_StructureManager : public Standard_Transient
{
public:
friend class Graphic3d_Structure;
- DEFINE_STANDARD_RTTIEXT(Graphic3d_StructureManager,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Graphic3d_StructureManager,Standard_Transient)
protected:
#include <HLRAlgo_EdgesBlock.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_EdgesBlock,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_EdgesBlock,Standard_Transient)
//=======================================================================
//function : HLRAlgo_EdgesBlock
#include <TColStd_Array1OfInteger.hxx>
#include <TColStd_Array1OfBoolean.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TopAbs_Orientation.hxx>
#include <Standard_Boolean.hxx>
class HLRAlgo_EdgesBlock;
-DEFINE_STANDARD_HANDLE(HLRAlgo_EdgesBlock, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(HLRAlgo_EdgesBlock, Standard_Transient)
//! An EdgesBlock is a set of Edges. It is used by the
//! DataStructure to structure the Edges.
//! Internal
//! Double
//! IsoLine)
-class HLRAlgo_EdgesBlock : public MMgt_TShared
+class HLRAlgo_EdgesBlock : public Standard_Transient
{
public:
return myMinMax;
}
- DEFINE_STANDARD_RTTIEXT(HLRAlgo_EdgesBlock,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(HLRAlgo_EdgesBlock,Standard_Transient)
protected:
#include <Precision.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_PolyAlgo,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_PolyAlgo,Standard_Transient)
//static Standard_Integer ERROR = Standard_False;
#include <HLRAlgo_ListIteratorOfListOfBPoint.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TColStd_Array1OfTransient.hxx>
class HLRAlgo_EdgeStatus;
class HLRAlgo_PolyAlgo;
-DEFINE_STANDARD_HANDLE(HLRAlgo_PolyAlgo, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(HLRAlgo_PolyAlgo, Standard_Transient)
//! to remove Hidden lines on Triangulations.
-class HLRAlgo_PolyAlgo : public MMgt_TShared
+class HLRAlgo_PolyAlgo : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(HLRAlgo_PolyAlgo,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(HLRAlgo_PolyAlgo,Standard_Transient)
protected:
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_PolyData,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_PolyData,Standard_Transient)
#ifdef OCCT_DEBUG
static Standard_Integer HLRAlgo_PolyData_ERROR = Standard_False;
#include <TColgp_HArray1OfXYZ.hxx>
#include <HLRAlgo_HArray1OfTData.hxx>
#include <HLRAlgo_HArray1OfPHDat.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TColgp_Array1OfXYZ.hxx>
#include <HLRAlgo_Array1OfTData.hxx>
#include <HLRAlgo_Array1OfPHDat.hxx>
class HLRAlgo_EdgeStatus;
class HLRAlgo_PolyData;
-DEFINE_STANDARD_HANDLE(HLRAlgo_PolyData, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(HLRAlgo_PolyData, Standard_Transient)
//! Data structure of a set of Triangles.
-class HLRAlgo_PolyData : public MMgt_TShared
+class HLRAlgo_PolyData : public Standard_Transient
{
public:
return myFaceIndices;
}
- DEFINE_STANDARD_RTTIEXT(HLRAlgo_PolyData,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(HLRAlgo_PolyData,Standard_Transient)
private:
#include <Standard_Stream.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_PolyInternalData,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_PolyInternalData,Standard_Transient)
#ifdef OCCT_DEBUG
static Standard_Integer HLRAlgo_PolyInternalData_TRACE = Standard_False;
#include <HLRAlgo_HArray1OfTData.hxx>
#include <HLRAlgo_HArray1OfPISeg.hxx>
#include <HLRAlgo_HArray1OfPINod.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Real.hxx>
#include <HLRAlgo_Array1OfTData.hxx>
#include <HLRAlgo_Array1OfPISeg.hxx>
class HLRAlgo_PolyInternalData;
-DEFINE_STANDARD_HANDLE(HLRAlgo_PolyInternalData, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(HLRAlgo_PolyInternalData, Standard_Transient)
//! to Update OutLines.
-class HLRAlgo_PolyInternalData : public MMgt_TShared
+class HLRAlgo_PolyInternalData : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(HLRAlgo_PolyInternalData,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(HLRAlgo_PolyInternalData,Standard_Transient)
protected:
#include <HLRAlgo_PolyInternalNode.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_PolyInternalNode,MMgt_TShared)
\ No newline at end of file
+IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_PolyInternalNode,Standard_Transient)
\ No newline at end of file
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <gp_XYZ.hxx>
#include <gp_XY.hxx>
class HLRAlgo_PolyInternalNode;
-DEFINE_STANDARD_HANDLE(HLRAlgo_PolyInternalNode, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(HLRAlgo_PolyInternalNode, Standard_Transient)
//! to Update OutLines.
-class HLRAlgo_PolyInternalNode : public MMgt_TShared
+class HLRAlgo_PolyInternalNode : public Standard_Transient
{
public:
struct NodeIndices
return myData;
}
- DEFINE_STANDARD_RTTIEXT(HLRAlgo_PolyInternalNode,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(HLRAlgo_PolyInternalNode,Standard_Transient)
private:
NodeIndices myIndices;
#include <HLRAlgo_PolyShellData.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_PolyShellData,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_PolyShellData,Standard_Transient)
//=======================================================================
//function : HLRAlgo_PolyShellData
#include <TColStd_Array1OfTransient.hxx>
#include <TColStd_HArray1OfTransient.hxx>
#include <HLRAlgo_ListOfBPoint.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
class HLRAlgo_PolyShellData;
-DEFINE_STANDARD_HANDLE(HLRAlgo_PolyShellData, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(HLRAlgo_PolyShellData, Standard_Transient)
//! All the PolyData of a Shell
-class HLRAlgo_PolyShellData : public MMgt_TShared
+class HLRAlgo_PolyShellData : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(HLRAlgo_PolyShellData,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(HLRAlgo_PolyShellData,Standard_Transient)
protected:
#include <HLRAlgo_WiresBlock.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_WiresBlock,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_WiresBlock,Standard_Transient)
#include <TColStd_Array1OfTransient.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class HLRAlgo_WiresBlock;
-DEFINE_STANDARD_HANDLE(HLRAlgo_WiresBlock, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(HLRAlgo_WiresBlock, Standard_Transient)
//! A WiresBlock is a set of Blocks. It is used by the
//! DataStructure to structure the Edges.
//! A WiresBlock contains :
//!
//! * An Array of Blocks.
-class HLRAlgo_WiresBlock : public MMgt_TShared
+class HLRAlgo_WiresBlock : public Standard_Transient
{
public:
//! Create a Block of Blocks.
return myMinMax;
}
- DEFINE_STANDARD_RTTIEXT(HLRAlgo_WiresBlock,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(HLRAlgo_WiresBlock,Standard_Transient)
private:
TColStd_Array1OfTransient myWires;
#include <HLRBRep_Algo.hxx>
#include <HLRBRep_ShapeBounds.hxx>
#include <HLRTopoBRep_OutLiner.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Type.hxx>
#include <TopoDS_Shape.hxx>
//=======================================================================
void HLRBRep_Algo::Add (const TopoDS_Shape& S,
- const Handle(MMgt_TShared)& SData,
+ const Handle(Standard_Transient)& SData,
const Standard_Integer nbIso)
{
Load(new HLRTopoBRep_OutLiner(S),SData,nbIso);
#include <HLRBRep_InternalAlgo.hxx>
#include <Standard_Integer.hxx>
class TopoDS_Shape;
-class MMgt_TShared;
+class Standard_Transient;
class HLRBRep_Algo;
Standard_EXPORT HLRBRep_Algo(const Handle(HLRBRep_Algo)& A);
//! add the Shape <S>.
- Standard_EXPORT void Add (const TopoDS_Shape& S, const Handle(MMgt_TShared)& SData, const Standard_Integer nbIso = 0);
+ Standard_EXPORT void Add (const TopoDS_Shape& S, const Handle(Standard_Transient)& SData, const Standard_Integer nbIso = 0);
//! Adds the shape S to this framework, and
//! specifies the number of isoparameters nbiso desired in visualizing S.
#include <HLRBRep_AreaLimit.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(HLRBRep_AreaLimit,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(HLRBRep_AreaLimit,Standard_Transient)
//=======================================================================
//function : HLRBRep_AreaLimit
#include <HLRAlgo_Intersection.hxx>
#include <Standard_Boolean.hxx>
#include <TopAbs_State.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class HLRAlgo_Intersection;
class HLRBRep_AreaLimit;
-DEFINE_STANDARD_HANDLE(HLRBRep_AreaLimit, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(HLRBRep_AreaLimit, Standard_Transient)
//! The private nested class AreaLimit represents a --
//! vertex on the Edge with the state on the left and --
//! the right.
-class HLRBRep_AreaLimit : public MMgt_TShared
+class HLRBRep_AreaLimit : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(HLRBRep_AreaLimit,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(HLRBRep_AreaLimit,Standard_Transient)
protected:
#include <TColStd_ListIteratorOfListOfInteger.hxx>
#include <stdio.h>
-IMPLEMENT_STANDARD_RTTIEXT(HLRBRep_Data,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(HLRBRep_Data,Standard_Transient)
Standard_Integer nbOkIntersection;
Standard_Integer nbPtIntersection;
#include <TopAbs_Orientation.hxx>
#include <HLRBRep_Intersector.hxx>
#include <HLRAlgo_Interference.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <BRepTopAdaptor_MapOfShapeTool.hxx>
#include <TopAbs_State.hxx>
#include <HLRAlgo_InterferenceList.hxx>
class HLRBRep_Data;
-DEFINE_STANDARD_HANDLE(HLRBRep_Data, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(HLRBRep_Data, Standard_Transient)
-class HLRBRep_Data : public MMgt_TShared
+class HLRBRep_Data : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(HLRBRep_Data,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(HLRBRep_Data,Standard_Transient)
protected:
#include <HLRBRep_ShapeBounds.hxx>
#include <HLRBRep_ShapeToHLR.hxx>
#include <HLRTopoBRep_OutLiner.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_ErrorHandler.hxx>
#include <Standard_OutOfRange.hxx>
#include <Standard_Stream.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <stdio.h>
-IMPLEMENT_STANDARD_RTTIEXT(HLRBRep_InternalAlgo,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(HLRBRep_InternalAlgo,Standard_Transient)
extern Standard_Integer nbPtIntersection; // total P.I.
extern Standard_Integer nbSegIntersection; // total S.I
//=======================================================================
void HLRBRep_InternalAlgo::Load (const Handle(HLRTopoBRep_OutLiner)& S,
- const Handle(MMgt_TShared)& SData,
+ const Handle(Standard_Transient)& SData,
const Standard_Integer nbIso)
{
myShapes.Append(HLRBRep_ShapeBounds(S,SData,nbIso,0,0,0,0,0,0));
//=======================================================================
void HLRBRep_InternalAlgo::ShapeData (const Standard_Integer I,
- const Handle(MMgt_TShared)& SData)
+ const Handle(Standard_Transient)& SData)
{
Standard_OutOfRange_Raise_if
(I == 0 || I > myShapes.Length(),
#include <HLRBRep_SeqOfShapeBounds.hxx>
#include <BRepTopAdaptor_MapOfShapeTool.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
class HLRBRep_Data;
class Standard_OutOfRange;
class HLRAlgo_Projector;
class HLRTopoBRep_OutLiner;
-class MMgt_TShared;
class HLRBRep_ShapeBounds;
class HLRBRep_InternalAlgo;
-DEFINE_STANDARD_HANDLE(HLRBRep_InternalAlgo, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(HLRBRep_InternalAlgo, Standard_Transient)
-class HLRBRep_InternalAlgo : public MMgt_TShared
+class HLRBRep_InternalAlgo : public Standard_Transient
{
public:
Standard_EXPORT void Update();
//! add the shape <S>.
- Standard_EXPORT void Load (const Handle(HLRTopoBRep_OutLiner)& S, const Handle(MMgt_TShared)& SData, const Standard_Integer nbIso = 0);
+ Standard_EXPORT void Load (const Handle(HLRTopoBRep_OutLiner)& S, const Handle(Standard_Transient)& SData, const Standard_Integer nbIso = 0);
//! add the shape <S>.
Standard_EXPORT void Load (const Handle(HLRTopoBRep_OutLiner)& S, const Standard_Integer nbIso = 0);
Standard_EXPORT void Remove (const Standard_Integer I);
//! Change the Shape Data of the Shape of index <I>.
- Standard_EXPORT void ShapeData (const Standard_Integer I, const Handle(MMgt_TShared)& SData);
+ Standard_EXPORT void ShapeData (const Standard_Integer I, const Handle(Standard_Transient)& SData);
Standard_EXPORT HLRBRep_SeqOfShapeBounds& SeqOfShapeBounds();
- DEFINE_STANDARD_RTTIEXT(HLRBRep_InternalAlgo,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(HLRBRep_InternalAlgo,Standard_Transient)
protected:
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(HLRBRep_PolyAlgo,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(HLRBRep_PolyAlgo,Standard_Transient)
enum
{
#include <BRepAdaptor_Surface.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_Curve2d.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
#include <TColStd_Array1OfTransient.hxx>
#include <TColStd_Array1OfInteger.hxx>
class HLRBRep_PolyAlgo;
-DEFINE_STANDARD_HANDLE(HLRBRep_PolyAlgo, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(HLRBRep_PolyAlgo, Standard_Transient)
//! to remove Hidden lines on Shapes with Triangulations.
//! A framework to compute the shape as seen in
//! the visible and hidden parts of each face in a
//! shape to be visualized by comparing each
//! face in the shape with every other face in the same shape.
-class HLRBRep_PolyAlgo : public MMgt_TShared
+class HLRBRep_PolyAlgo : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(HLRBRep_PolyAlgo,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(HLRBRep_PolyAlgo,Standard_Transient)
protected:
#include <HLRBRep_ShapeBounds.hxx>
#include <HLRTopoBRep_OutLiner.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
//=======================================================================
//function : HLRBRep_ShapeBounds
//=======================================================================
HLRBRep_ShapeBounds::
HLRBRep_ShapeBounds (const Handle(HLRTopoBRep_OutLiner)& S,
- const Handle(MMgt_TShared)& SData,
+ const Handle(Standard_Transient)& SData,
const Standard_Integer nbIso,
const Standard_Integer V1,
const Standard_Integer V2,
#include <Standard_Integer.hxx>
class HLRTopoBRep_OutLiner;
-class MMgt_TShared;
+class Standard_Transient;
//! Contains a Shape and the bounds of its vertices,
HLRBRep_ShapeBounds();
- Standard_EXPORT HLRBRep_ShapeBounds(const Handle(HLRTopoBRep_OutLiner)& S, const Handle(MMgt_TShared)& SData, const Standard_Integer nbIso, const Standard_Integer V1, const Standard_Integer V2, const Standard_Integer E1, const Standard_Integer E2, const Standard_Integer F1, const Standard_Integer F2);
+ Standard_EXPORT HLRBRep_ShapeBounds(const Handle(HLRTopoBRep_OutLiner)& S, const Handle(Standard_Transient)& SData, const Standard_Integer nbIso, const Standard_Integer V1, const Standard_Integer V2, const Standard_Integer E1, const Standard_Integer E2, const Standard_Integer F1, const Standard_Integer F2);
Standard_EXPORT HLRBRep_ShapeBounds(const Handle(HLRTopoBRep_OutLiner)& S, const Standard_Integer nbIso, const Standard_Integer V1, const Standard_Integer V2, const Standard_Integer E1, const Standard_Integer E2, const Standard_Integer F1, const Standard_Integer F2);
const Handle(HLRTopoBRep_OutLiner)& Shape() const;
- void ShapeData (const Handle(MMgt_TShared)& SD);
+ void ShapeData (const Handle(Standard_Transient)& SD);
- const Handle(MMgt_TShared)& ShapeData() const;
+ const Handle(Standard_Transient)& ShapeData() const;
void NbOfIso (const Standard_Integer nbIso);
Handle(HLRTopoBRep_OutLiner) myShape;
- Handle(MMgt_TShared) myShapeData;
+ Handle(Standard_Transient) myShapeData;
Standard_Integer myNbIso;
Standard_Integer myVertStart;
Standard_Integer myVertEnd;
//=======================================================================
inline void HLRBRep_ShapeBounds::
-ShapeData (const Handle(MMgt_TShared)& SD)
+ShapeData (const Handle(Standard_Transient)& SD)
{ myShapeData = SD; }
//=======================================================================
//purpose :
//=======================================================================
-inline const Handle(MMgt_TShared) & HLRBRep_ShapeBounds::ShapeData () const
+inline const Handle(Standard_Transient) & HLRBRep_ShapeBounds::ShapeData () const
{ return myShapeData; }
//=======================================================================
#include <HLRTest_ShapeData.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(HLRTest_ShapeData,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(HLRTest_ShapeData,Standard_Transient)
//=======================================================================
//function : HLRTest_ShapeData
#include <Standard_Type.hxx>
#include <Draw_Color.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class Draw_Color;
class HLRTest_ShapeData;
-DEFINE_STANDARD_HANDLE(HLRTest_ShapeData, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(HLRTest_ShapeData, Standard_Transient)
//! Contains the colors of a shape.
-class HLRTest_ShapeData : public MMgt_TShared
+class HLRTest_ShapeData : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(HLRTest_ShapeData,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(HLRTest_ShapeData,Standard_Transient)
protected:
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(HLRTopoBRep_OutLiner,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(HLRTopoBRep_OutLiner,Standard_Transient)
//=======================================================================
//function : OutLiner
#include <TopoDS_Shape.hxx>
#include <HLRTopoBRep_Data.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <BRepTopAdaptor_MapOfShapeTool.hxx>
#include <Standard_Integer.hxx>
class TopoDS_Shape;
class HLRTopoBRep_OutLiner;
-DEFINE_STANDARD_HANDLE(HLRTopoBRep_OutLiner, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(HLRTopoBRep_OutLiner, Standard_Transient)
-class HLRTopoBRep_OutLiner : public MMgt_TShared
+class HLRTopoBRep_OutLiner : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(HLRTopoBRep_OutLiner,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(HLRTopoBRep_OutLiner,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(HeaderSection_FileDescription,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(HeaderSection_FileDescription,Standard_Transient)
HeaderSection_FileDescription::HeaderSection_FileDescription () {}
#include <Standard_Type.hxx>
#include <Interface_HArray1OfHAsciiString.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
class TCollection_HAsciiString;
class HeaderSection_FileDescription;
-DEFINE_STANDARD_HANDLE(HeaderSection_FileDescription, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(HeaderSection_FileDescription, Standard_Transient)
-class HeaderSection_FileDescription : public MMgt_TShared
+class HeaderSection_FileDescription : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(HeaderSection_FileDescription,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(HeaderSection_FileDescription,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(HeaderSection_FileName,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(HeaderSection_FileName,Standard_Transient)
HeaderSection_FileName::HeaderSection_FileName () {}
#include <Standard_Type.hxx>
#include <Interface_HArray1OfHAsciiString.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
class TCollection_HAsciiString;
class HeaderSection_FileName;
-DEFINE_STANDARD_HANDLE(HeaderSection_FileName, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(HeaderSection_FileName, Standard_Transient)
-class HeaderSection_FileName : public MMgt_TShared
+class HeaderSection_FileName : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(HeaderSection_FileName,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(HeaderSection_FileName,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(HeaderSection_FileSchema,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(HeaderSection_FileSchema,Standard_Transient)
HeaderSection_FileSchema::HeaderSection_FileSchema () {}
#include <Standard_Type.hxx>
#include <Interface_HArray1OfHAsciiString.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
class TCollection_HAsciiString;
class HeaderSection_FileSchema;
-DEFINE_STANDARD_HANDLE(HeaderSection_FileSchema, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(HeaderSection_FileSchema, Standard_Transient)
-class HeaderSection_FileSchema : public MMgt_TShared
+class HeaderSection_FileSchema : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(HeaderSection_FileSchema,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(HeaderSection_FileSchema,Standard_Transient)
protected:
#include <TColStd_SequenceOfTransient.hxx>
#include <NCollection_DataMap.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(IFSelect_Activator,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(IFSelect_Activator,Standard_Transient)
static NCollection_DataMap<TCollection_AsciiString, Standard_Integer> thedico;
static TColStd_SequenceOfInteger thenums, themodes;
#include <Standard_Type.hxx>
#include <TCollection_AsciiString.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
#include <Standard_CString.hxx>
#include <Standard_Boolean.hxx>
class IFSelect_Activator;
-DEFINE_STANDARD_HANDLE(IFSelect_Activator, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IFSelect_Activator, Standard_Transient)
//! Defines the general frame for working with a SessionPilot.
//! Each Activator treats a set of Commands. Commands are given as
//!
//! The result of an Execution must indicate if it is worth to be
//! recorded or not : see method Do
-class IFSelect_Activator : public MMgt_TShared
+class IFSelect_Activator : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(IFSelect_Activator,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(IFSelect_Activator,Standard_Transient)
protected:
#include <IFSelect_GeneralModifier.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(IFSelect_AppliedModifiers,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(IFSelect_AppliedModifiers,Standard_Transient)
IFSelect_AppliedModifiers::IFSelect_AppliedModifiers
(const Standard_Integer nbmax, const Standard_Integer nbent)
#include <IFSelect_SequenceOfGeneralModifier.hxx>
#include <Interface_IntList.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <TColStd_HSequenceOfInteger.hxx>
class IFSelect_GeneralModifier;
class IFSelect_AppliedModifiers;
-DEFINE_STANDARD_HANDLE(IFSelect_AppliedModifiers, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IFSelect_AppliedModifiers, Standard_Transient)
//! This class allows to memorize and access to the modifiers
//! which are to be applied to a file. To each modifier, is bound
//!
//! for (i = 1; i <= entcount; i ++)
//! nument = ItemNum (i); -> return an entity number
-class IFSelect_AppliedModifiers : public MMgt_TShared
+class IFSelect_AppliedModifiers : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(IFSelect_AppliedModifiers,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(IFSelect_AppliedModifiers,Standard_Transient)
protected:
#include <TCollection_AsciiString.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(IFSelect_Dispatch,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(IFSelect_Dispatch,Standard_Transient)
void IFSelect_Dispatch::SetRootName
(const Handle(TCollection_HAsciiString)& name)
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
class TCollection_HAsciiString;
class IFSelect_Dispatch;
-DEFINE_STANDARD_HANDLE(IFSelect_Dispatch, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IFSelect_Dispatch, Standard_Transient)
//! This class allows to describe how a set of Entities has to be
//! dispatched into resulting Packets : a Packet is a sub-set of
//! The input set is read from a specified Selection, attached to
//! the Dispatch : the Final Selection of the Dispatch. The input
//! is the Unique Root Entities list of the Final Selection
-class IFSelect_Dispatch : public MMgt_TShared
+class IFSelect_Dispatch : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(IFSelect_Dispatch,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(IFSelect_Dispatch,Standard_Transient)
protected:
#include <TCollection_HAsciiString.hxx>
#include <TColStd_HSequenceOfHAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(IFSelect_EditForm,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(IFSelect_EditForm,Standard_Transient)
IFSelect_EditForm::IFSelect_EditForm
(const Handle(IFSelect_Editor)& editor,
#include <TColStd_Array1OfInteger.hxx>
#include <TColStd_Array1OfTransient.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
#include <TColStd_SequenceOfInteger.hxx>
#include <TColStd_HSequenceOfHAsciiString.hxx>
class IFSelect_EditForm;
-DEFINE_STANDARD_HANDLE(IFSelect_EditForm, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IFSelect_EditForm, Standard_Transient)
//! An EditForm is the way to apply an Editor on an Entity or on
//! the Model
//! may differ if it is not Complete
//! Two methods give the correspondance between this Number and
//! the Rank in the EditForm : RankFromNumber and NumberFromRank
-class IFSelect_EditForm : public MMgt_TShared
+class IFSelect_EditForm : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(IFSelect_EditForm,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(IFSelect_EditForm,Standard_Transient)
protected:
#include <TCollection_HAsciiString.hxx>
#include <string.h>
-IMPLEMENT_STANDARD_RTTIEXT(IFSelect_Editor,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(IFSelect_Editor,Standard_Transient)
IFSelect_Editor::IFSelect_Editor (const Standard_Integer nbval)
: thenbval (nbval) , themaxsh (0) , themaxco (0) , themaxla (0) ,
#include <TColStd_Array1OfTransient.hxx>
#include <TColStd_Array1OfAsciiString.hxx>
#include <TColStd_Array1OfInteger.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
#include <IFSelect_EditValue.hxx>
#include <Standard_Boolean.hxx>
class IFSelect_Editor;
-DEFINE_STANDARD_HANDLE(IFSelect_Editor, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IFSelect_Editor, Standard_Transient)
//! An Editor defines a set of values and a way to edit them, on
//! an entity or on the model (e.g. on its header)
//! Each Value is controlled by a TypedValue, with a number (it is
//! an Integer) and a name under two forms (complete and short)
//! and an edit mode
-class IFSelect_Editor : public MMgt_TShared
+class IFSelect_Editor : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(IFSelect_Editor,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(IFSelect_Editor,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TCollection_AsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(IFSelect_GeneralModifier,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(IFSelect_GeneralModifier,Standard_Transient)
IFSelect_GeneralModifier::IFSelect_GeneralModifier
(const Standard_Boolean maychangegraph) { thechgr = maychangegraph; }
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class IFSelect_Selection;
class IFSelect_Dispatch;
class TCollection_AsciiString;
class IFSelect_GeneralModifier;
-DEFINE_STANDARD_HANDLE(IFSelect_GeneralModifier, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IFSelect_GeneralModifier, Standard_Transient)
//! This class gives a frame for Actions which modify the effect
//! of a Dispatch, i.e. :
//! their kind of action, which can be applied at a precise step
//! of the production of a File : see Modifier, and in the
//! package IFAdapt, EntityModifier and EntityCopier
-class IFSelect_GeneralModifier : public MMgt_TShared
+class IFSelect_GeneralModifier : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(IFSelect_GeneralModifier,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(IFSelect_GeneralModifier,Standard_Transient)
protected:
#include <Interface_Static.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(IFSelect_IntParam,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(IFSelect_IntParam,Standard_Transient)
IFSelect_IntParam::IFSelect_IntParam ()
{ theval = 0; }
#include <Standard_Integer.hxx>
#include <TCollection_AsciiString.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
class IFSelect_IntParam;
-DEFINE_STANDARD_HANDLE(IFSelect_IntParam, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IFSelect_IntParam, Standard_Transient)
//! This class simply allows to access an Integer value through a
//! Handle, as a String can be (by using HString).
//! For an Integer, an IntParam can designate (by its name) a
//! Static : each time its value is required or set, the Static
//! is aknowledged
-class IFSelect_IntParam : public MMgt_TShared
+class IFSelect_IntParam : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(IFSelect_IntParam,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(IFSelect_IntParam,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(IFSelect_ListEditor,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(IFSelect_ListEditor,Standard_Transient)
IFSelect_ListEditor::IFSelect_ListEditor ()
: themax (0) , thetouc (0) { }
#include <Standard_Integer.hxx>
#include <TColStd_HSequenceOfHAsciiString.hxx>
#include <TColStd_HSequenceOfInteger.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
class Interface_TypedValue;
class Interface_InterfaceModel;
class IFSelect_ListEditor;
-DEFINE_STANDARD_HANDLE(IFSelect_ListEditor, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IFSelect_ListEditor, Standard_Transient)
//! A ListEditor is an auxiliary operator for Editor/EditForm
//! I.E. it works on parameter values expressed as strings
//! An EditList is produced by the Editor, with a basic definition
//! This definition (brought by this class) can be redefined
//! Hence the Editor may produce a specific ListEditor as needed
-class IFSelect_ListEditor : public MMgt_TShared
+class IFSelect_ListEditor : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(IFSelect_ListEditor,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(IFSelect_ListEditor,Standard_Transient)
protected:
#include <TColStd_HSequenceOfInteger.hxx>
#include <stdio.h>
-IMPLEMENT_STANDARD_RTTIEXT(IFSelect_ModelCopier,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(IFSelect_ModelCopier,Standard_Transient)
//#define MISOPOINT
IFSelect_ModelCopier::IFSelect_ModelCopier () { }
#include <IFSelect_SequenceOfAppliedModifiers.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <TColStd_HSequenceOfHAsciiString.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
#include <Standard_CString.hxx>
class IFSelect_ModelCopier;
-DEFINE_STANDARD_HANDLE(IFSelect_ModelCopier, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IFSelect_ModelCopier, Standard_Transient)
//! This class performs the Copy operations involved by the
//! description of a ShareOut (evaluated by a ShareOutResult)
//! also in package IFAdapt : a sub-class of ModelCopier allows
//! to work with EntityModifier, in addition to Modifier itself
//! which still applies to a whole copied Model.
-class IFSelect_ModelCopier : public MMgt_TShared
+class IFSelect_ModelCopier : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(IFSelect_ModelCopier,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(IFSelect_ModelCopier,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TColStd_HSequenceOfInteger.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(IFSelect_PacketList,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(IFSelect_PacketList,Standard_Transient)
IFSelect_PacketList::IFSelect_PacketList
(const Handle(Interface_InterfaceModel)& model)
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
#include <TCollection_AsciiString.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
#include <TColStd_HSequenceOfTransient.hxx>
class Interface_InterfaceModel;
class IFSelect_PacketList;
-DEFINE_STANDARD_HANDLE(IFSelect_PacketList, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IFSelect_PacketList, Standard_Transient)
//! This class gives a simple way to return then consult a
//! list of packets, determined from the content of a Model,
//! given model, possibly more than one list knowing every entity,
//! and to determine the remaining list (entities in no lists) and
//! the duplications (with their count).
-class IFSelect_PacketList : public MMgt_TShared
+class IFSelect_PacketList : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(IFSelect_PacketList,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(IFSelect_PacketList,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TCollection_AsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(IFSelect_Selection,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(IFSelect_Selection,Standard_Transient)
Standard_Boolean IFSelect_Selection::HasUniqueResult () const
{ return Standard_False; } // eminemment redefinissable
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
class Interface_InterfaceError;
class Interface_EntityIterator;
class IFSelect_Selection;
-DEFINE_STANDARD_HANDLE(IFSelect_Selection, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IFSelect_Selection, Standard_Transient)
//! A Selection allows to define a set of Interface Entities.
//! Entities to be put on an output file should be identified in
//! Its input can be, either an Interface Model (the very source),
//! or another-other Selection(s) or any other ouput. All list
//! computations start from an input Graph (from IFGraph)
-class IFSelect_Selection : public MMgt_TShared
+class IFSelect_Selection : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(IFSelect_Selection,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(IFSelect_Selection,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TCollection_AsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(IFSelect_SessionDumper,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(IFSelect_SessionDumper,Standard_Transient)
static Handle(IFSelect_SessionDumper) thefirst;
static int cefait = 0;
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
class IFSelect_SessionFile;
class Standard_Transient;
class IFSelect_SessionDumper;
-DEFINE_STANDARD_HANDLE(IFSelect_SessionDumper, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IFSelect_SessionDumper, Standard_Transient)
//! A SessionDumper is called by SessionFile. It takes into
//! account a set of classes (such as Selections, Dispatches ...).
//!
//! SessionDumpers are organized in a Library which is used by
//! SessionFile. They are put at Creation Time in this Library.
-class IFSelect_SessionDumper : public MMgt_TShared
+class IFSelect_SessionDumper : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(IFSelect_SessionDumper,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(IFSelect_SessionDumper,Standard_Transient)
protected:
#include <TCollection_HAsciiString.hxx>
#include <stdio.h>
-IMPLEMENT_STANDARD_RTTIEXT(IFSelect_ShareOut,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(IFSelect_ShareOut,Standard_Transient)
IFSelect_ShareOut::IFSelect_ShareOut ()
{
#include <IFSelect_TSeqOfDispatch.hxx>
#include <IFSelect_SequenceOfGeneralModifier.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
class TCollection_HAsciiString;
class Interface_InterfaceError;
class IFSelect_ShareOut;
-DEFINE_STANDARD_HANDLE(IFSelect_ShareOut, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IFSelect_ShareOut, Standard_Transient)
//! This class gathers the informations required to produce one or
//! several file(s) from the content of an InterfaceModel (passing
//! entities per file; "forgotten" entities; duplicated entities),
//! exploitation (generation of derivated Models, each of them
//! generating an output file)
-class IFSelect_ShareOut : public MMgt_TShared
+class IFSelect_ShareOut : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(IFSelect_ShareOut,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(IFSelect_ShareOut,Standard_Transient)
protected:
#include <TCollection_HAsciiString.hxx>
#include <TColStd_HSequenceOfTransient.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(IFSelect_SignatureList,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(IFSelect_SignatureList,Standard_Transient)
IFSelect_SignatureList::IFSelect_SignatureList
(const Standard_Boolean withlist)
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
#include <TCollection_AsciiString.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
#include <TColStd_HSequenceOfHAsciiString.hxx>
#include <TColStd_HSequenceOfTransient.hxx>
class IFSelect_SignatureList;
-DEFINE_STANDARD_HANDLE(IFSelect_SignatureList, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IFSelect_SignatureList, Standard_Transient)
//! A SignatureList is given as result from a Counter (any kind)
//! It gives access to a list of signatures, with counts, and
//! Mode. This can be useful for a specific counter (used in a
//! Selection), while it remains better to use a Signature
//! whenever possible
-class IFSelect_SignatureList : public MMgt_TShared
+class IFSelect_SignatureList : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(IFSelect_SignatureList,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(IFSelect_SignatureList,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TCollection_AsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(IFSelect_Transformer,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(IFSelect_Transformer,Standard_Transient)
Standard_Boolean IFSelect_Transformer::ChangeProtocol (Handle(Interface_Protocol)& ) const
{
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
class Interface_Graph;
class Interface_Protocol;
class IFSelect_Transformer;
-DEFINE_STANDARD_HANDLE(IFSelect_Transformer, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IFSelect_Transformer, Standard_Transient)
//! A Transformer defines the way an InterfaceModel is transformed
//! (without sending it to a file).
//! (typically on the same type, but some or all entities beeing
//! rebuilt or converted; or converted from a protocol to
//! another one)
-class IFSelect_Transformer : public MMgt_TShared
+class IFSelect_Transformer : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(IFSelect_Transformer,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(IFSelect_Transformer,Standard_Transient)
protected:
#include <TCollection_HAsciiString.hxx>
#include <TColStd_MapOfInteger.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(IFSelect_WorkSession,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(IFSelect_WorkSession,Standard_Transient)
#define Flag_Incorrect 2
// (Bit Map n0 2)
#include <TCollection_AsciiString.hxx>
#include <Interface_CheckIterator.hxx>
#include <TColStd_IndexedDataMapOfTransientTransient.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <NCollection_Vector.hxx>
#include <NCollection_DataMap.hxx>
#include <Standard_CString.hxx>
class IFSelect_WorkSession;
-DEFINE_STANDARD_HANDLE(IFSelect_WorkSession, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IFSelect_WorkSession, Standard_Transient)
//! This class can be used to simply manage a process such as
//! splitting a file, extracting a set of Entities ...
//! Text Parameters, Selections, Dispatches, in addition to a
//! ShareOut. To each of these variables, a unique Integer
//! Identifier is attached. A Name can be attached too as desired.
-class IFSelect_WorkSession : public MMgt_TShared
+class IFSelect_WorkSession : public Standard_Transient
{
public:
//! 2 gives a form suitable for givelist : (n1,n2,n3...)
Standard_EXPORT void ListEntities (const Interface_EntityIterator& iter, const Standard_Integer mode) const;
- DEFINE_STANDARD_RTTIEXT(IFSelect_WorkSession,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(IFSelect_WorkSession,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TColStd_Array1OfTransient.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <IGESData_HArray1OfIGESEntity.hxx>
#include <Standard_Integer.hxx>
class IGESBasic_HArray1OfHArray1OfIGESEntity;
-DEFINE_STANDARD_HANDLE(IGESBasic_HArray1OfHArray1OfIGESEntity, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IGESBasic_HArray1OfHArray1OfIGESEntity, Standard_Transient)
-class IGESBasic_HArray1OfHArray1OfIGESEntity : public MMgt_TShared
+class IGESBasic_HArray1OfHArray1OfIGESEntity : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTI_INLINE(IGESBasic_HArray1OfHArray1OfIGESEntity,MMgt_TShared)
+ DEFINE_STANDARD_RTTI_INLINE(IGESBasic_HArray1OfHArray1OfIGESEntity,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TColStd_Array1OfTransient.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <Standard_Integer.hxx>
class IGESBasic_HArray1OfHArray1OfInteger;
-DEFINE_STANDARD_HANDLE(IGESBasic_HArray1OfHArray1OfInteger, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IGESBasic_HArray1OfHArray1OfInteger, Standard_Transient)
-class IGESBasic_HArray1OfHArray1OfInteger : public MMgt_TShared
+class IGESBasic_HArray1OfHArray1OfInteger : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTI_INLINE(IGESBasic_HArray1OfHArray1OfInteger,MMgt_TShared)
+ DEFINE_STANDARD_RTTI_INLINE(IGESBasic_HArray1OfHArray1OfInteger,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TColStd_Array1OfTransient.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <Standard_Integer.hxx>
class IGESBasic_HArray1OfHArray1OfReal;
-DEFINE_STANDARD_HANDLE(IGESBasic_HArray1OfHArray1OfReal, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IGESBasic_HArray1OfHArray1OfReal, Standard_Transient)
-class IGESBasic_HArray1OfHArray1OfReal : public MMgt_TShared
+class IGESBasic_HArray1OfHArray1OfReal : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTI_INLINE(IGESBasic_HArray1OfHArray1OfReal,MMgt_TShared)
+ DEFINE_STANDARD_RTTI_INLINE(IGESBasic_HArray1OfHArray1OfReal,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TColStd_Array1OfTransient.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TColgp_HArray1OfXY.hxx>
#include <Standard_Integer.hxx>
class IGESBasic_HArray1OfHArray1OfXY;
-DEFINE_STANDARD_HANDLE(IGESBasic_HArray1OfHArray1OfXY, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IGESBasic_HArray1OfHArray1OfXY, Standard_Transient)
-class IGESBasic_HArray1OfHArray1OfXY : public MMgt_TShared
+class IGESBasic_HArray1OfHArray1OfXY : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTI_INLINE(IGESBasic_HArray1OfHArray1OfXY,MMgt_TShared)
+ DEFINE_STANDARD_RTTI_INLINE(IGESBasic_HArray1OfHArray1OfXY,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TColStd_Array1OfTransient.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TColgp_HArray1OfXYZ.hxx>
#include <Standard_Integer.hxx>
class IGESBasic_HArray1OfHArray1OfXYZ;
-DEFINE_STANDARD_HANDLE(IGESBasic_HArray1OfHArray1OfXYZ, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IGESBasic_HArray1OfHArray1OfXYZ, Standard_Transient)
-class IGESBasic_HArray1OfHArray1OfXYZ : public MMgt_TShared
+class IGESBasic_HArray1OfHArray1OfXYZ : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTI_INLINE(IGESBasic_HArray1OfHArray1OfXYZ,MMgt_TShared)
+ DEFINE_STANDARD_RTTI_INLINE(IGESBasic_HArray1OfHArray1OfXYZ,Standard_Transient)
protected:
#include <TCollection_HAsciiString.hxx>
#include <stdio.h>
-IMPLEMENT_STANDARD_RTTIEXT(IGESData_IGESEntity,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(IGESData_IGESEntity,Standard_Transient)
#define ThisEntity Handle(IGESData_IGESEntity)::DownCast(This())
#include <Standard_Real.hxx>
#include <Standard_Character.hxx>
#include <Interface_EntityList.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <IGESData_DefType.hxx>
#include <IGESData_DefList.hxx>
class IGESData_IGESEntity;
-DEFINE_STANDARD_HANDLE(IGESData_IGESEntity, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IGESData_IGESEntity, Standard_Transient)
//! defines root of IGES Entity definition, including Directory
//! Part, lists of (optionnal) Properties and Associativities
-class IGESData_IGESEntity : public MMgt_TShared
+class IGESData_IGESEntity : public Standard_Transient
{
public:
friend class IGESData_DirChecker;
- DEFINE_STANDARD_RTTIEXT(IGESData_IGESEntity,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(IGESData_IGESEntity,Standard_Transient)
protected:
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class IGESData_GlobalNodeOfSpecificLib;
class IGESData_IGESEntity;
class IGESData_SpecificModule;
class IGESData_NodeOfSpecificLib;
-DEFINE_STANDARD_HANDLE(IGESData_NodeOfSpecificLib, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IGESData_NodeOfSpecificLib, Standard_Transient)
-class IGESData_NodeOfSpecificLib : public MMgt_TShared
+class IGESData_NodeOfSpecificLib : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTI_INLINE(IGESData_NodeOfSpecificLib,MMgt_TShared)
+ DEFINE_STANDARD_RTTI_INLINE(IGESData_NodeOfSpecificLib,Standard_Transient)
protected:
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class IGESData_GlobalNodeOfWriterLib;
class IGESData_IGESEntity;
class IGESData_ReadWriteModule;
class IGESData_NodeOfWriterLib;
-DEFINE_STANDARD_HANDLE(IGESData_NodeOfWriterLib, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IGESData_NodeOfWriterLib, Standard_Transient)
-class IGESData_NodeOfWriterLib : public MMgt_TShared
+class IGESData_NodeOfWriterLib : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTI_INLINE(IGESData_NodeOfWriterLib,MMgt_TShared)
+ DEFINE_STANDARD_RTTI_INLINE(IGESData_NodeOfWriterLib,Standard_Transient)
protected:
#include <Standard_DomainError.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(IGESData_ToolLocation,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(IGESData_ToolLocation,Standard_Transient)
#define TYPEFORASSOC 402
#include <Standard_Real.hxx>
#include <Interface_GeneralLib.hxx>
#include <TColStd_Array1OfInteger.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
class IGESData_IGESModel;
class Standard_DomainError;
class IGESData_ToolLocation;
-DEFINE_STANDARD_HANDLE(IGESData_ToolLocation, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IGESData_ToolLocation, Standard_Transient)
//! This Tool determines and gives access to effective Locations
//! of IGES Entities as defined by the IGES Norm. These Locations
//!
//! This is a TShared object, then it is easier to use in an
//! interactive session
-class IGESData_ToolLocation : public MMgt_TShared
+class IGESData_ToolLocation : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(IGESData_ToolLocation,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(IGESData_ToolLocation,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TColStd_Array1OfTransient.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <IGESGraph_HArray1OfTextDisplayTemplate.hxx>
#include <Standard_Integer.hxx>
class IGESDefs_HArray1OfHArray1OfTextDisplayTemplate;
-DEFINE_STANDARD_HANDLE(IGESDefs_HArray1OfHArray1OfTextDisplayTemplate, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IGESDefs_HArray1OfHArray1OfTextDisplayTemplate, Standard_Transient)
-class IGESDefs_HArray1OfHArray1OfTextDisplayTemplate : public MMgt_TShared
+class IGESDefs_HArray1OfHArray1OfTextDisplayTemplate : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTI_INLINE(IGESDefs_HArray1OfHArray1OfTextDisplayTemplate,MMgt_TShared)
+ DEFINE_STANDARD_RTTI_INLINE(IGESDefs_HArray1OfHArray1OfTextDisplayTemplate,Standard_Transient)
protected:
#include <Standard_Transient.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(IGESSelect_ViewSorter,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(IGESSelect_ViewSorter,Standard_Transient)
#define PourDrawing 404
#include <TColStd_IndexedMapOfTransient.hxx>
#include <TColStd_SequenceOfInteger.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <TColStd_HSequenceOfTransient.hxx>
#include <Standard_Integer.hxx>
class IGESSelect_ViewSorter;
-DEFINE_STANDARD_HANDLE(IGESSelect_ViewSorter, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IGESSelect_ViewSorter, Standard_Transient)
//! Sorts IGES Entities on the views and drawings.
//! In a first step, it splits a set of entities according the
//!
//! It is a TShared, hence it can be a workomg field of a non-
//! mutable object (a Dispatch for instance)
-class IGESSelect_ViewSorter : public MMgt_TShared
+class IGESSelect_ViewSorter : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(IGESSelect_ViewSorter,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(IGESSelect_ViewSorter,Standard_Transient)
protected:
#include <IGESToBRep_ToolContainer.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(IGESToBRep_AlgoContainer,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(IGESToBRep_AlgoContainer,Standard_Transient)
//=======================================================================
//function : IGESToBRep_AlgoContainer
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class IGESToBRep_ToolContainer;
class IGESToBRep_AlgoContainer;
-DEFINE_STANDARD_HANDLE(IGESToBRep_AlgoContainer, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IGESToBRep_AlgoContainer, Standard_Transient)
-class IGESToBRep_AlgoContainer : public MMgt_TShared
+class IGESToBRep_AlgoContainer : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(IGESToBRep_AlgoContainer,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(IGESToBRep_AlgoContainer,Standard_Transient)
protected:
#include <TopoDS_Face.hxx>
#include <TopoDS_Wire.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(IGESToBRep_IGESBoundary,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(IGESToBRep_IGESBoundary,Standard_Transient)
//=======================================================================
//function : IGESToBRep_IGESBoundary
#include <gp_Trsf2d.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <IGESData_HArray1OfIGESEntity.hxx>
class IGESData_IGESEntity;
class IGESToBRep_IGESBoundary;
-DEFINE_STANDARD_HANDLE(IGESToBRep_IGESBoundary, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IGESToBRep_IGESBoundary, Standard_Transient)
//! This class is intended to translate IGES boundary entity
//! (142-CurveOnSurface, 141-Boundary or 508-Loop) into the wire.
//! Methods Transfer are virtual and are redefined in Advanced
//! Data Exchange to optimize the translation and take into
//! account advanced parameters.
-class IGESToBRep_IGESBoundary : public MMgt_TShared
+class IGESToBRep_IGESBoundary : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(IGESToBRep_IGESBoundary,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(IGESToBRep_IGESBoundary,Standard_Transient)
protected:
#include <IGESToBRep_ToolContainer.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(IGESToBRep_ToolContainer,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(IGESToBRep_ToolContainer,Standard_Transient)
//=======================================================================
//function : IGESToBRep_ToolContainer
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class IGESToBRep_IGESBoundary;
class IGESToBRep_ToolContainer;
-DEFINE_STANDARD_HANDLE(IGESToBRep_ToolContainer, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IGESToBRep_ToolContainer, Standard_Transient)
-class IGESToBRep_ToolContainer : public MMgt_TShared
+class IGESToBRep_ToolContainer : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(IGESToBRep_ToolContainer,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(IGESToBRep_ToolContainer,Standard_Transient)
protected:
#include <Standard.hxx>
#include <Standard_Macro.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#ifdef _WIN32
#include <windows.h>
#include <Standard_OutOfRange.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(IntPatch_Line,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(IntPatch_Line,Standard_Transient)
IntPatch_Line::IntPatch_Line (const Standard_Boolean Tang,
const IntSurf_TypeTrans Trans1,
#include <Standard_Boolean.hxx>
#include <IntSurf_TypeTrans.hxx>
#include <IntSurf_Situation.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class Standard_DomainError;
class Standard_OutOfRange;
class IntPatch_Line;
-DEFINE_STANDARD_HANDLE(IntPatch_Line, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IntPatch_Line, Standard_Transient)
//! Definition of an intersection line between two
//! surfaces.
//! or analytic, as defined in the class ALine, or defined
//! by a set of points (coming from a walking algorithm) as
//! defined in the class WLine.
-class IntPatch_Line : public MMgt_TShared
+class IntPatch_Line : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(IntPatch_Line,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(IntPatch_Line,Standard_Transient)
protected:
#include <Standard_Integer.hxx>
#include <IntSurf_PathPoint.hxx>
#include <gp_Vec.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <IntSurf_Allocator.hxx>
class IntSurf_LineOn2S;
class Standard_OutOfRange;
class IntPatch_TheIWLineOfTheIWalking;
-DEFINE_STANDARD_HANDLE(IntPatch_TheIWLineOfTheIWalking, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IntPatch_TheIWLineOfTheIWalking, Standard_Transient)
-class IntPatch_TheIWLineOfTheIWalking : public MMgt_TShared
+class IntPatch_TheIWLineOfTheIWalking : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTI_INLINE(IntPatch_TheIWLineOfTheIWalking,MMgt_TShared)
+ DEFINE_STANDARD_RTTI_INLINE(IntPatch_TheIWLineOfTheIWalking,Standard_Transient)
protected:
#include <IntStart_SITopolTool.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(IntStart_SITopolTool,MMgt_TShared)
\ No newline at end of file
+IMPLEMENT_STANDARD_RTTIEXT(IntStart_SITopolTool,Standard_Transient)
\ No newline at end of file
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TopAbs_State.hxx>
#include <Standard_Real.hxx>
class gp_Pnt2d;
class IntStart_SITopolTool;
-DEFINE_STANDARD_HANDLE(IntStart_SITopolTool, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IntStart_SITopolTool, Standard_Transient)
//! template class for a topological tool.
//! This tool is linked with the surface on which
//! the classification has to be made.
-class IntStart_SITopolTool : public MMgt_TShared
+class IntStart_SITopolTool : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(IntStart_SITopolTool,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(IntStart_SITopolTool,Standard_Transient)
protected:
#include <Standard_OutOfRange.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(IntSurf_LineOn2S,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(IntSurf_LineOn2S,Standard_Transient)
IntSurf_LineOn2S::IntSurf_LineOn2S (const IntSurf_Allocator& theAllocator) :
mySeq (theAllocator)
#include <Standard_Type.hxx>
#include <IntSurf_SequenceOfPntOn2S.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <IntSurf_Allocator.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
class IntSurf_LineOn2S;
-DEFINE_STANDARD_HANDLE(IntSurf_LineOn2S, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(IntSurf_LineOn2S, Standard_Transient)
-class IntSurf_LineOn2S : public MMgt_TShared
+class IntSurf_LineOn2S : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(IntSurf_LineOn2S,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(IntSurf_LineOn2S,Standard_Transient)
protected:
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
#include <Precision.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TopAbs_State.hxx>
#include <Standard_Boolean.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <Standard_Type.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Interface_Check,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Interface_Check,Standard_Transient)
// Un Check est cree au depart sans liste de message : celle ci est creee
// seulement si au moins une erreur doit y etre enregitree (Fail-Warning)
#include <Standard_Type.hxx>
#include <TColStd_HSequenceOfHAsciiString.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
#endif
class Interface_Check;
-DEFINE_STANDARD_HANDLE(Interface_Check, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Interface_Check, Standard_Transient)
//! Defines a Check, as a list of Fail or Warning Messages under
//! a literal form, which can be empty. A Check can also bring an
//! inserted (integers, reals, strings)
//! The original form can be more suitable for some operations
//! such as counting messages
-class Interface_Check : public MMgt_TShared
+class Interface_Check : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Interface_Check,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Interface_Check,Standard_Transient)
protected:
#include <Standard_Transient.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Interface_CopyControl,MMgt_TShared)
\ No newline at end of file
+IMPLEMENT_STANDARD_RTTIEXT(Interface_CopyControl,Standard_Transient)
\ No newline at end of file
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
class Interface_InterfaceError;
class Standard_Transient;
class Interface_CopyControl;
-DEFINE_STANDARD_HANDLE(Interface_CopyControl, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Interface_CopyControl, Standard_Transient)
//! This deferred class describes the services required by
//! CopyTool to work. They are very simple and correspond
//! But they can be provided by various classes which can
//! control a Transfer. Each Starting Entity have at most
//! one Result (Mapping one-one)
-class Interface_CopyControl : public MMgt_TShared
+class Interface_CopyControl : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Interface_CopyControl,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Interface_CopyControl,Standard_Transient)
protected:
#include <Standard_Transient.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Interface_EntityCluster,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Interface_EntityCluster,Standard_Transient)
// Un Cluster, ce sont 4 entites qui se suivent (dans le principe, nombre fixe,
// meme si pas 4). Elles sont remplies depuis 0. Il y a donc autant d Entites
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
class Standard_Transient;
class Interface_EntityCluster;
-DEFINE_STANDARD_HANDLE(Interface_EntityCluster, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Interface_EntityCluster, Standard_Transient)
//! Auxiliary class for EntityList. An EntityList designates an
//! EntityCluster, which brings itself an fixed maximum count of
//! little count. It is designed for a light management.
//! Remark that a new Item may not be Null, because this is the
//! criterium used for "End of List"
-class Interface_EntityCluster : public MMgt_TShared
+class Interface_EntityCluster : public Standard_Transient
{
public:
friend class Interface_EntityList;
- DEFINE_STANDARD_RTTIEXT(Interface_EntityCluster,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Interface_EntityCluster,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TCollection_AsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Interface_FileReaderData,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Interface_FileReaderData,Standard_Transient)
// Stoque les Donnees issues d un Fichier (Conservees sous forme Litterale)
// Chaque norme peut s en servir comme base (listes de parametres litteraux,
#include <Standard_Integer.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <TColStd_Array1OfTransient.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
#include <Interface_ParamType.hxx>
#include <Standard_Boolean.hxx>
class Interface_FileReaderData;
-DEFINE_STANDARD_HANDLE(Interface_FileReaderData, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Interface_FileReaderData, Standard_Transient)
//! This class defines services which permit to access Data issued
//! from a File, in a form which does not depend of physical
//! FileReaderData inherits TShared to be accessed by Handle :
//! this allows FileReaderTool to define more easily the specific
//! methods, and improves memory management.
-class Interface_FileReaderData : public MMgt_TShared
+class Interface_FileReaderData : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Interface_FileReaderData,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Interface_FileReaderData,Standard_Transient)
protected:
#include <Standard_Transient.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Interface_GTool,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Interface_GTool,Standard_Transient)
Interface_GTool::Interface_GTool () { }
#include <Interface_GeneralLib.hxx>
#include <Interface_DataMapOfTransientInteger.hxx>
#include <TColStd_IndexedDataMapOfTransientTransient.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
#include <Standard_CString.hxx>
#include <Standard_Boolean.hxx>
class Interface_GTool;
-DEFINE_STANDARD_HANDLE(Interface_GTool, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Interface_GTool, Standard_Transient)
//! GTool - General Tool for a Model
//! Provides the functions performed by Protocol/GeneralModule for
//! Optimized : once an entity has been queried, the GeneralLib is
//! not longer queried
//! Shareable between several users : as a Handle
-class Interface_GTool : public MMgt_TShared
+class Interface_GTool : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Interface_GTool,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Interface_GTool,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Interface_GeneralModule,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Interface_GeneralModule,Standard_Transient)
void Interface_GeneralModule::FillShared
(const Handle(Interface_InterfaceModel)& /*model*/,
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
class Interface_InterfaceModel;
class Interface_GeneralModule;
-DEFINE_STANDARD_HANDLE(Interface_GeneralModule, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Interface_GeneralModule, Standard_Transient)
//! This class defines general services, which must be provided
//! for each type of Entity (i.e. of Transient Object processed
//! then calls Module), each recognized Entity Type corresponds
//! to a Case Number, determined by the Protocol each class of
//! GeneralModule belongs to.
-class Interface_GeneralModule : public MMgt_TShared
+class Interface_GeneralModule : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Interface_GeneralModule,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Interface_GeneralModule,Standard_Transient)
protected:
#include <Standard_DomainError.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Interface_HGraph,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Interface_HGraph,Standard_Transient)
Interface_HGraph::Interface_HGraph (const Interface_Graph& agraph)
: thegraph(agraph) { }
#include <Standard_Type.hxx>
#include <Interface_Graph.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
class Standard_DomainError;
class Interface_Graph;
class Interface_HGraph;
-DEFINE_STANDARD_HANDLE(Interface_HGraph, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Interface_HGraph, Standard_Transient)
//! This class allows to store a redefinable Graph, via a Handle
//! (usefull for an Object which can work on several successive
//! Models, with the same general conditions)
-class Interface_HGraph : public MMgt_TShared
+class Interface_HGraph : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Interface_HGraph,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Interface_HGraph,Standard_Transient)
protected:
#include <Interface_IntVal.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Interface_IntVal,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Interface_IntVal,Standard_Transient)
Interface_IntVal::Interface_IntVal () { theval = 0; }
#include <Standard_Type.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class Interface_IntVal;
-DEFINE_STANDARD_HANDLE(Interface_IntVal, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Interface_IntVal, Standard_Transient)
//! An Integer through a Handle (i.e. managed as TShared)
-class Interface_IntVal : public MMgt_TShared
+class Interface_IntVal : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Interface_IntVal,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Interface_IntVal,Standard_Transient)
protected:
#include <TColStd_Array1OfTransient.hxx>
#include <TColStd_DataMapIteratorOfDataMapOfIntegerTransient.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Interface_InterfaceModel, MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Interface_InterfaceModel, Standard_Transient)
// Un Modele d`Interface est un ensemble ferme d`Entites d`interface : chacune
// est dans un seul modele a la fois; elle y a un numero (Number) qui permet de
#include <TColStd_IndexedMapOfTransient.hxx>
#include <TColStd_DataMapOfIntegerTransient.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Type.hxx>
#include <Standard_CString.hxx>
class Interface_InterfaceModel;
-DEFINE_STANDARD_HANDLE(Interface_InterfaceModel, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Interface_InterfaceModel, Standard_Transient)
//! Defines an (Indexed) Set of data corresponding to a complete
//! Transfer by a File Interface, i.e. File Header and Transient
//! under another name).
//!
//! See also Graph, ShareTool, CheckTool for more
-class Interface_InterfaceModel : public MMgt_TShared
+class Interface_InterfaceModel : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Interface_InterfaceModel,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Interface_InterfaceModel,Standard_Transient)
protected:
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class Interface_GlobalNodeOfGeneralLib;
class Standard_Transient;
class Interface_GeneralModule;
class Interface_NodeOfGeneralLib;
-DEFINE_STANDARD_HANDLE(Interface_NodeOfGeneralLib, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Interface_NodeOfGeneralLib, Standard_Transient)
-class Interface_NodeOfGeneralLib : public MMgt_TShared
+class Interface_NodeOfGeneralLib : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTI_INLINE(Interface_NodeOfGeneralLib,MMgt_TShared)
+ DEFINE_STANDARD_RTTI_INLINE(Interface_NodeOfGeneralLib,Standard_Transient)
protected:
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class Interface_GlobalNodeOfReaderLib;
class Standard_Transient;
class Interface_ReaderModule;
class Interface_NodeOfReaderLib;
-DEFINE_STANDARD_HANDLE(Interface_NodeOfReaderLib, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Interface_NodeOfReaderLib, Standard_Transient)
-class Interface_NodeOfReaderLib : public MMgt_TShared
+class Interface_NodeOfReaderLib : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTI_INLINE(Interface_NodeOfReaderLib,MMgt_TShared)
+ DEFINE_STANDARD_RTTI_INLINE(Interface_NodeOfReaderLib,Standard_Transient)
protected:
#include <Standard_RangeError.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Interface_ParamList,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Interface_ParamList,Standard_Transient)
//=======================================================================
//function : Interface_ParamList
#include <Standard_Type.hxx>
#include <Interface_VectorOfFileParameter.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
class Standard_RangeError;
class Standard_OutOfRange;
class Interface_ParamList;
-DEFINE_STANDARD_HANDLE(Interface_ParamList, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Interface_ParamList, Standard_Transient)
-class Interface_ParamList : public MMgt_TShared
+class Interface_ParamList : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Interface_ParamList,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Interface_ParamList,Standard_Transient)
protected:
#include <Standard_OutOfRange.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Interface_ParamSet,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Interface_ParamSet,Standard_Transient)
Interface_ParamSet::Interface_ParamSet (const Standard_Integer nres, const Standard_Integer )//nst)
{
#include <Standard_PCharacter.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
#include <Interface_ParamType.hxx>
class Interface_ParamList;
class Interface_ParamSet;
-DEFINE_STANDARD_HANDLE(Interface_ParamSet, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Interface_ParamSet, Standard_Transient)
//! Defines an ordered set of FileParameters, in a way to be
//! efficient as in memory requirement or in speed
-class Interface_ParamSet : public MMgt_TShared
+class Interface_ParamSet : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Interface_ParamSet,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Interface_ParamSet,Standard_Transient)
protected:
#include <Standard_Transient.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Interface_Protocol,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Interface_Protocol,Standard_Transient)
// Gestion du Protocol actif : tres simple, une variable statique
static Handle(Interface_Protocol)& theactive()
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Type.hxx>
class Interface_Protocol;
-DEFINE_STANDARD_HANDLE(Interface_Protocol, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Interface_Protocol, Standard_Transient)
//! General description of Interface Protocols. A Protocol defines
//! a set of Entity types. This class provides also the notion of
//! It also gives control of type definitions. By default, types
//! are provided by CDL, but specific implementations, or topics
//! like multi-typing, may involve another way
-class Interface_Protocol : public MMgt_TShared
+class Interface_Protocol : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Interface_Protocol,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Interface_Protocol,Standard_Transient)
protected:
#include <Standard_Transient.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Interface_ReaderModule,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Interface_ReaderModule,Standard_Transient)
Standard_Boolean Interface_ReaderModule::NewRead(const Standard_Integer,
const Handle(Interface_FileReaderData)&,
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
class Standard_DomainError;
class Interface_ReaderModule;
-DEFINE_STANDARD_HANDLE(Interface_ReaderModule, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Interface_ReaderModule, Standard_Transient)
//! Defines unitary operations required to read an Entity from a
//! File (see FileReaderData, FileReaderTool), under control of
//! To work, a GeneralModule has formerly recognized the Type read
//! from FileReaderData as a positive Case Number, then the
//! ReaderModule reads it according to this Case Number
-class Interface_ReaderModule : public MMgt_TShared
+class Interface_ReaderModule : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Interface_ReaderModule,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Interface_ReaderModule,Standard_Transient)
protected:
#include <Standard_Transient.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Interface_ReportEntity,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Interface_ReportEntity,Standard_Transient)
//=======================================================================
//function : Interface_ReportEntity
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
class Interface_Check;
class Standard_Transient;
class Interface_ReportEntity;
-DEFINE_STANDARD_HANDLE(Interface_ReportEntity, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Interface_ReportEntity, Standard_Transient)
//! A ReportEntity is produced to aknowledge and memorize the
//! binding between a Check and an Entity. The Check can bring
//! use the class UndefinedContent to brings parameters : it is
//! enough for most of information and avoids to redefine them,
//! only the specific part remains to be defined for each norm.
-class Interface_ReportEntity : public MMgt_TShared
+class Interface_ReportEntity : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Interface_ReportEntity,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Interface_ReportEntity,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Interface_UndefinedContent,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Interface_UndefinedContent,Standard_Transient)
#define Content_TypeField 31
#define Content_LocalField 7
#include <TColStd_HArray1OfInteger.hxx>
#include <Interface_HArray1OfHAsciiString.hxx>
#include <Interface_EntityList.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Interface_ParamType.hxx>
class Standard_OutOfRange;
class Interface_UndefinedContent;
-DEFINE_STANDARD_HANDLE(Interface_UndefinedContent, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Interface_UndefinedContent, Standard_Transient)
//! Defines resources for an "Undefined Entity" : such an Entity
//! is used to describe an Entity which complies with the Norm,
//!
//! Finally, the Protocols of each norm have to Create and
//! Recognize Unknown Entities of this norm
-class Interface_UndefinedContent : public MMgt_TShared
+class Interface_UndefinedContent : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Interface_UndefinedContent,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Interface_UndefinedContent,Standard_Transient)
protected:
#ifndef Interface_VectorOfFileParameter_HeaderFile
#define Interface_VectorOfFileParameter_HeaderFile
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <NCollection_Vector.hxx>
#include <Interface_FileParameter.hxx>
#include <LDOMBasicString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(LDOM_MemManager,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(LDOM_MemManager,Standard_Transient)
#define HASH_MASK 255
#define MINIMAL_ROOM 3
#ifndef LDOM_MemManager_HeaderFile
#define LDOM_MemManager_HeaderFile
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Type.hxx>
class LDOM_Document;
class LDOMBasicString;
// Define handle class for LDOM_MemManager
-DEFINE_STANDARD_HANDLE (LDOM_MemManager, MMgt_TShared)
+DEFINE_STANDARD_HANDLE (LDOM_MemManager, Standard_Transient)
// Class LDOM_MemManager (underlying structure of LDOM_Document)
//
-class LDOM_MemManager : public MMgt_TShared
+class LDOM_MemManager : public Standard_Transient
{
public:
// ---------- PUBLIC METHODS ----------
public:
// CASCADE RTTI
- DEFINE_STANDARD_RTTIEXT(LDOM_MemManager,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(LDOM_MemManager,Standard_Transient)
};
#include <Standard_RangeError.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Law_BSpline,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Law_BSpline,Standard_Transient)
#define POLES (poles->Array1())
#define KNOTS (knots->Array1())
#include <Standard_Integer.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <TColStd_HArray1OfInteger.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <Standard_Real.hxx>
class Law_BSpline;
-DEFINE_STANDARD_HANDLE(Law_BSpline, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Law_BSpline, Standard_Transient)
//! Definition of the 1D B_spline curve.
//!
//! . Modelisation des surfaces en CAO, Henri GIAUME Peugeot SA
//! . Curves and Surfaces for Computer Aided Geometric Design,
//! a practical guide Gerald Farin
-class Law_BSpline : public MMgt_TShared
+class Law_BSpline : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Law_BSpline,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Law_BSpline,Standard_Transient)
protected:
#include <Standard_OutOfRange.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Law_Function,MMgt_TShared)
\ No newline at end of file
+IMPLEMENT_STANDARD_RTTIEXT(Law_Function,Standard_Transient)
\ No newline at end of file
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <GeomAbs_Shape.hxx>
#include <Standard_Integer.hxx>
#include <TColStd_Array1OfReal.hxx>
class Law_Function;
-DEFINE_STANDARD_HANDLE(Law_Function, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Law_Function, Standard_Transient)
//! Root class for evolution laws.
-class Law_Function : public MMgt_TShared
+class Law_Function : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Law_Function,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Law_Function,Standard_Transient)
protected:
#include <TopoDS_Face.hxx>
#include <TopoDS_Vertex.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(LocOpe_GeneratedShape,MMgt_TShared)
\ No newline at end of file
+IMPLEMENT_STANDARD_RTTIEXT(LocOpe_GeneratedShape,Standard_Transient)
\ No newline at end of file
#include <Standard_Type.hxx>
#include <TopTools_ListOfShape.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TopoDS_Edge;
class TopoDS_Vertex;
class TopoDS_Face;
class LocOpe_GeneratedShape;
-DEFINE_STANDARD_HANDLE(LocOpe_GeneratedShape, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(LocOpe_GeneratedShape, Standard_Transient)
-class LocOpe_GeneratedShape : public MMgt_TShared
+class LocOpe_GeneratedShape : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(LocOpe_GeneratedShape,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(LocOpe_GeneratedShape,Standard_Transient)
protected:
#include <ShapeConstruct_ProjectCurveOnSurface.hxx>
#include <ShapeAnalysis.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(LocOpe_WiresOnShape,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(LocOpe_WiresOnShape,Standard_Transient)
static Standard_Boolean Project(const TopoDS_Vertex&,
const gp_Pnt2d&,
#include <Standard_Boolean.hxx>
#include <TopTools_DataMapOfShapeShape.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Real.hxx>
#include <TopTools_SequenceOfShape.hxx>
class LocOpe_WiresOnShape;
-DEFINE_STANDARD_HANDLE(LocOpe_WiresOnShape, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(LocOpe_WiresOnShape, Standard_Transient)
-class LocOpe_WiresOnShape : public MMgt_TShared
+class LocOpe_WiresOnShape : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(LocOpe_WiresOnShape,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(LocOpe_WiresOnShape,Standard_Transient)
protected:
#include <Standard_DomainError.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(MAT_Arc,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(MAT_Arc,Standard_Transient)
//========================================================================
// function:
#include <Standard_Integer.hxx>
#include <Standard_Address.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <MAT_Side.hxx>
class MAT_BasicElt;
class MAT_Arc;
-DEFINE_STANDARD_HANDLE(MAT_Arc, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(MAT_Arc, Standard_Transient)
//! An Arc is associated to each Bisecting of the mat.
-class MAT_Arc : public MMgt_TShared
+class MAT_Arc : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(MAT_Arc,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(MAT_Arc,Standard_Transient)
protected:
#include <MAT_SequenceOfArc.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(MAT_BasicElt,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(MAT_BasicElt,Standard_Transient)
//========================================================================
// function:
#include <Standard_Address.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class MAT_Arc;
class MAT_BasicElt;
-DEFINE_STANDARD_HANDLE(MAT_BasicElt, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(MAT_BasicElt, Standard_Transient)
//! A BasicELt is associated to each elemtary
//! constituant of the figure.
-class MAT_BasicElt : public MMgt_TShared
+class MAT_BasicElt : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(MAT_BasicElt,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(MAT_BasicElt,Standard_Transient)
protected:
#include <Precision.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(MAT_Bisector,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(MAT_Bisector,Standard_Transient)
MAT_Bisector::MAT_Bisector()
{
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class MAT_Edge;
class MAT_ListOfBisector;
class MAT_Bisector;
-DEFINE_STANDARD_HANDLE(MAT_Bisector, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(MAT_Bisector, Standard_Transient)
-class MAT_Bisector : public MMgt_TShared
+class MAT_Bisector : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(MAT_Bisector,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(MAT_Bisector,Standard_Transient)
protected:
#include <MAT_Edge.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(MAT_Edge,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(MAT_Edge,Standard_Transient)
MAT_Edge::MAT_Edge()
{
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class MAT_Bisector;
class MAT_Edge;
-DEFINE_STANDARD_HANDLE(MAT_Edge, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(MAT_Edge, Standard_Transient)
-class MAT_Edge : public MMgt_TShared
+class MAT_Edge : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(MAT_Edge,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(MAT_Edge,Standard_Transient)
protected:
#include <Precision.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(MAT_Graph,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(MAT_Graph,Standard_Transient)
//------------------
// functions static.
#include <MAT_DataMapOfIntegerBasicElt.hxx>
#include <MAT_DataMapOfIntegerNode.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
class MAT_ListOfBisector;
class MAT_Arc;
class MAT_Graph;
-DEFINE_STANDARD_HANDLE(MAT_Graph, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(MAT_Graph, Standard_Transient)
//! The Class Graph permits the exploration of the
//! Bisector Locus.
-class MAT_Graph : public MMgt_TShared
+class MAT_Graph : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(MAT_Graph,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(MAT_Graph,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
class MAT_TListNodeOfListOfBisector;
class MAT_Bisector;
class MAT_ListOfBisector;
-DEFINE_STANDARD_HANDLE(MAT_ListOfBisector, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(MAT_ListOfBisector, Standard_Transient)
-class MAT_ListOfBisector : public MMgt_TShared
+class MAT_ListOfBisector : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTI_INLINE(MAT_ListOfBisector,MMgt_TShared)
+ DEFINE_STANDARD_RTTI_INLINE(MAT_ListOfBisector,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
class MAT_TListNodeOfListOfEdge;
class MAT_Edge;
class MAT_ListOfEdge;
-DEFINE_STANDARD_HANDLE(MAT_ListOfEdge, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(MAT_ListOfEdge, Standard_Transient)
-class MAT_ListOfEdge : public MMgt_TShared
+class MAT_ListOfEdge : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTI_INLINE(MAT_ListOfEdge,MMgt_TShared)
+ DEFINE_STANDARD_RTTI_INLINE(MAT_ListOfEdge,Standard_Transient)
protected:
#include <Precision.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(MAT_Node,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(MAT_Node,Standard_Transient)
//=============================================================================
//function :
#include <Standard_Integer.hxx>
#include <Standard_Address.hxx>
#include <Standard_Real.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <MAT_SequenceOfArc.hxx>
#include <MAT_SequenceOfBasicElt.hxx>
#include <Standard_Boolean.hxx>
class MAT_Node;
-DEFINE_STANDARD_HANDLE(MAT_Node, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(MAT_Node, Standard_Transient)
//! Node of Graph.
-class MAT_Node : public MMgt_TShared
+class MAT_Node : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(MAT_Node,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(MAT_Node,Standard_Transient)
protected:
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class MAT_Bisector;
class MAT_ListOfBisector;
class MAT_TListNodeOfListOfBisector;
-DEFINE_STANDARD_HANDLE(MAT_TListNodeOfListOfBisector, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(MAT_TListNodeOfListOfBisector, Standard_Transient)
-class MAT_TListNodeOfListOfBisector : public MMgt_TShared
+class MAT_TListNodeOfListOfBisector : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTI_INLINE(MAT_TListNodeOfListOfBisector,MMgt_TShared)
+ DEFINE_STANDARD_RTTI_INLINE(MAT_TListNodeOfListOfBisector,Standard_Transient)
protected:
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class MAT_Edge;
class MAT_ListOfEdge;
class MAT_TListNodeOfListOfEdge;
-DEFINE_STANDARD_HANDLE(MAT_TListNodeOfListOfEdge, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(MAT_TListNodeOfListOfEdge, Standard_Transient)
-class MAT_TListNodeOfListOfEdge : public MMgt_TShared
+class MAT_TListNodeOfListOfEdge : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTI_INLINE(MAT_TListNodeOfListOfEdge,MMgt_TShared)
+ DEFINE_STANDARD_RTTI_INLINE(MAT_TListNodeOfListOfEdge,Standard_Transient)
protected:
#include <MAT_Zone.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(MAT_Zone,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(MAT_Zone,Standard_Transient)
//========================================================================
// function:
#include <MAT_SequenceOfArc.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
#include <MAT_Side.hxx>
class MAT_BasicElt;
class MAT_Zone;
-DEFINE_STANDARD_HANDLE(MAT_Zone, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(MAT_Zone, Standard_Transient)
//! Definition of Zone of Proximity of a BasicElt :
//! ----------------------------------------------
//! A Zone of proximity is the set of the points which are
//! more near from the BasicElt than any other.
-class MAT_Zone : public MMgt_TShared
+class MAT_Zone : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(MAT_Zone,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(MAT_Zone,Standard_Transient)
protected:
#include <TColStd_Array1OfInteger.hxx>
#include <TColStd_SequenceOfInteger.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(MAT2d_Circuit,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(MAT2d_Circuit,Standard_Transient)
#ifdef OCCT_DEBUG
#include <GCE2d_MakeSegment.hxx>
#include <TColStd_SequenceOfInteger.hxx>
#include <GeomAbs_JoinType.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <MAT2d_SequenceOfSequenceOfGeometry.hxx>
#include <TColStd_SequenceOfBoolean.hxx>
#include <Standard_Integer.hxx>
class MAT2d_Circuit;
-DEFINE_STANDARD_HANDLE(MAT2d_Circuit, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(MAT2d_Circuit, Standard_Transient)
//! Constructs a circuit on a set of lines.
//! EquiCircuit gives a Circuit passing by all the lines
//! in a set and all the connexions of the minipath associated.
-class MAT2d_Circuit : public MMgt_TShared
+class MAT2d_Circuit : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(MAT2d_Circuit,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(MAT2d_Circuit,Standard_Transient)
protected:
#include <MAT2d_Connexion.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(MAT2d_Connexion,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(MAT2d_Connexion,Standard_Transient)
//=============================================================================
//function :
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
#include <gp_Pnt2d.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
class gp_Pnt2d;
class MAT2d_Connexion;
-DEFINE_STANDARD_HANDLE(MAT2d_Connexion, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(MAT2d_Connexion, Standard_Transient)
//! A Connexion links two lines of items in a set
//! of lines. It s contains two points and their paramatric
//! definitions on the lines.
//! The items can be points or curves.
-class MAT2d_Connexion : public MMgt_TShared
+class MAT2d_Connexion : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(MAT2d_Connexion,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(MAT2d_Connexion,Standard_Transient)
protected:
-MMgt_TShared.cxx
MMgt_TShared.hxx
+++ /dev/null
-// Copyright (c) 1998-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-
-#include <MMgt_TShared.hxx>
-#include <Standard_OutOfMemory.hxx>
-#include <Standard_Type.hxx>
-
-IMPLEMENT_STANDARD_RTTIEXT(MMgt_TShared,Standard_Transient)
-
-//=======================================================================
-//function : Delete
-//purpose :
-//=======================================================================
-void MMgt_TShared::Delete() const
-{
- delete (MMgt_TShared *)this;
-}
-
#ifndef _MMgt_TShared_HeaderFile
#define _MMgt_TShared_HeaderFile
-#include <Standard.hxx>
-#include <Standard_Type.hxx>
-
#include <Standard_Transient.hxx>
-class Standard_OutOfMemory;
-
-
-class MMgt_TShared;
-DEFINE_STANDARD_HANDLE(MMgt_TShared, Standard_Transient)
-
-
-//! Intermediate class between Standard_Transient
-//! and descendants.
-//! The abstract class TShared is the root class of
-//! managed objects. TShared objects are managed
-//! by a memory manager based on reference
-//! counting. They have handle semantics. In other
-//! words, the reference counter is transparently
-//! incremented and decremented according to the
-//! scope of handles. When all handles, which
-//! reference a single object are out of scope, the
-//! reference counter becomes null and the object is
-//! automatically deleted. The deallocated memory is
-//! not given back to the system though. It is
-//! reclaimed for new objects of the same size.
-//! Warning
-//! This memory management scheme does not
-//! work for cyclic data structures. In such cases
-//! (with back pointers for example), you should
-//! interrupt the cycle in a class by using a full C++
-//! pointer instead of a handle.
-class MMgt_TShared : public Standard_Transient
-{
-
-public:
-
-
- Standard_EXPORT virtual void Delete() const Standard_OVERRIDE;
-
-
-
-
- DEFINE_STANDARD_RTTIEXT(MMgt_TShared,Standard_Transient)
-
-protected:
-
-
-
-
-private:
-
-
-
-
-};
-
-
-
-
-
+Standard_DEPRECATED("Type is deprecated, Standard_Transient should be used instead")
+typedef Standard_Transient MMgt_TShared;
#endif // _MMgt_TShared_HeaderFile
#include <TColStd_HPackedMapOfInteger.hxx>
#include <TColStd_MapIteratorOfPackedMapOfInteger.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(MeshVS_DataSource,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(MeshVS_DataSource,Standard_Transient)
//================================================================
// Function : Get3DGeom
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
#include <TColStd_Array1OfReal.hxx>
class MeshVS_DataSource;
-DEFINE_STANDARD_HANDLE(MeshVS_DataSource, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(MeshVS_DataSource, Standard_Transient)
//! The deferred class using for the following tasks:
//! 1) Receiving geometry data about single element of node by its number;
//! - one sensitive entity for the whole mesh and for each selection mode
//! Receiving of IDs of detected entities (nodes and elements) in a viewer is achieved by
//! implementation of a group of methods GetDetectedEntities.
-class MeshVS_DataSource : public MMgt_TShared
+class MeshVS_DataSource : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(MeshVS_DataSource,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(MeshVS_DataSource,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TCollection_AsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(MeshVS_Drawer,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(MeshVS_Drawer,Standard_Transient)
//================================================================
// Function : Assign
#include <MeshVS_DataMapOfIntegerColor.hxx>
#include <MeshVS_DataMapOfIntegerMaterial.hxx>
#include <MeshVS_DataMapOfIntegerAsciiString.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
#include <Standard_Boolean.hxx>
class MeshVS_Drawer;
-DEFINE_STANDARD_HANDLE(MeshVS_Drawer, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(MeshVS_Drawer, Standard_Transient)
//! This class provided the common interface to share between classes
//! big set of constants affecting to object appearance. By default, this class
//! can store integers, doubles, OCC colors, OCC materials. Each of OCC enum members
//! can be stored as integers.
-class MeshVS_Drawer : public MMgt_TShared
+class MeshVS_Drawer : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(MeshVS_Drawer,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(MeshVS_Drawer,Standard_Transient)
protected:
#include <SelectBasics_SensitiveEntity.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(MeshVS_PrsBuilder,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(MeshVS_PrsBuilder,Standard_Transient)
//================================================================
// Function : Constructor MeshVS_PrsBuilder
#include <MeshVS_MeshPtr.hxx>
#include <Standard_Integer.hxx>
#include <PrsMgr_PresentationManager3d.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <MeshVS_DisplayModeFlags.hxx>
#include <MeshVS_BuilderPriority.hxx>
#include <TColStd_PackedMapOfInteger.hxx>
class MeshVS_PrsBuilder;
-DEFINE_STANDARD_HANDLE(MeshVS_PrsBuilder, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(MeshVS_PrsBuilder, Standard_Transient)
//! This class is parent for all builders using in MeshVS_Mesh.
//! It provides base fields and methods all buildes need.
-class MeshVS_PrsBuilder : public MMgt_TShared
+class MeshVS_PrsBuilder : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(MeshVS_PrsBuilder,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(MeshVS_PrsBuilder,Standard_Transient)
protected:
#include <TColStd_MapIteratorOfPackedMapOfInteger.hxx>
#include <TColStd_SequenceOfInteger.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Message_Algorithm,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Message_Algorithm,Standard_Transient)
//=======================================================================
//function : Message_Algorithm
#include <Message_ExecStatus.hxx>
#include <TColStd_HArray1OfTransient.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Message_Status.hxx>
#include <Standard_Integer.hxx>
#include <Standard_CString.hxx>
class Message_Algorithm;
-DEFINE_STANDARD_HANDLE(Message_Algorithm, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Message_Algorithm, Standard_Transient)
//! Class Message_Algorithm is intended to be the base class for
//! classes implementing algorithms or any operations that need
//! The messages are output to the messenger, stored in the field;
//! though messenger can be changed, it is guaranteed to be non-null.
//! By default, Message::DefaultMessenger() is used.
-class Message_Algorithm : public MMgt_TShared
+class Message_Algorithm : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Message_Algorithm,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Message_Algorithm,Standard_Transient)
protected:
#include <TCollection_AsciiString.hxx>
#include <TCollection_ExtendedString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Message_Messenger,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Message_Messenger,Standard_Transient)
//=======================================================================
//function : Message_Messenger
#include <Standard_Type.hxx>
#include <Message_SequenceOfPrinters.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Type.hxx>
#endif
class Message_Messenger;
-DEFINE_STANDARD_HANDLE(Message_Messenger, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Message_Messenger, Standard_Transient)
//! Messenger is API class providing general-purpose interface for
//! libraries that may issue text messages without knowledge
//! argument being Handle(Message_Messenger); thus it can be used
//! with syntax similar to C++ streams.
//! Note that all these operators use trace level Warning.
-class Message_Messenger : public MMgt_TShared
+class Message_Messenger : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Message_Messenger,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Message_Messenger,Standard_Transient)
protected:
#include <TCollection_AsciiString.hxx>
#include <TCollection_ExtendedString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Message_Printer,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Message_Printer,Standard_Transient)
//=======================================================================
//function : Constructor
#include <Standard_Type.hxx>
#include <Message_Gravity.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_CString.hxx>
class TCollection_ExtendedString;
class Message_Printer;
-DEFINE_STANDARD_HANDLE(Message_Printer, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Message_Printer, Standard_Transient)
//! Abstract interface class defining printer as output context for text messages
//!
//! The message, besides being text string, has associated gravity
//! level, which can be used by printer to decide either to process a message or ignore it.
-class Message_Printer : public MMgt_TShared
+class Message_Printer : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Message_Printer,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Message_Printer,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Message_ProgressIndicator,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Message_ProgressIndicator,Standard_Transient)
//=======================================================================
//function : Message_ProgressIndicator
#include <Standard_Real.hxx>
#include <Message_SequenceOfProgressScale.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
class Message_ProgressIndicator;
-DEFINE_STANDARD_HANDLE(Message_ProgressIndicator, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Message_ProgressIndicator, Standard_Transient)
//! Defines abstract interface from program to the "user".
//! That includes progress indication and user break mechanisms
//! progress indicator (e.g. show total position at the graphical bar,
//! and/or print all scopes in text mode), and for implementation
//! of user break mechanism (if defined).
-class Message_ProgressIndicator : public MMgt_TShared
+class Message_ProgressIndicator : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Message_ProgressIndicator,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Message_ProgressIndicator,Standard_Transient)
protected:
#include <TopoDS_Shape.hxx>
#include <NCollection_DataMap.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(MoniTool_CaseData,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(MoniTool_CaseData,Standard_Transient)
static NCollection_DataMap<TCollection_AsciiString, Standard_Integer> defch;
static NCollection_DataMap<TCollection_AsciiString, Handle(Standard_Transient)> defms;
#include <TColStd_SequenceOfTransient.hxx>
#include <TColStd_SequenceOfInteger.hxx>
#include <TColStd_SequenceOfAsciiString.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Real.hxx>
class MoniTool_CaseData;
-DEFINE_STANDARD_HANDLE(MoniTool_CaseData, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(MoniTool_CaseData, Standard_Transient)
//! This class is intended to record data attached to a case to be
//! exploited.
//! * else, an interpreted identifier, which gives the type and
//! the rank in the type (for instance, first integer; etc)
//! (See NameRank)
-class MoniTool_CaseData : public MMgt_TShared
+class MoniTool_CaseData : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(MoniTool_CaseData,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(MoniTool_CaseData,Standard_Transient)
protected:
#include <MoniTool_Element.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(MoniTool_Element,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(MoniTool_Element,Standard_Transient)
void MoniTool_Element::SetHashCode (const Standard_Integer code)
{ thecode = code; }
#include <Standard_Integer.hxx>
#include <MoniTool_AttrList.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Type.hxx>
#include <Standard_CString.hxx>
class MoniTool_Element;
-DEFINE_STANDARD_HANDLE(MoniTool_Element, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(MoniTool_Element, Standard_Transient)
//! a Element allows to map any kind of object as a Key for a Map.
//! This works by defining, for a Hash Code, that of the real Key,
//! not of the Element which acts only as an intermediate.
//! When a Map asks for the HashCode of a Element, this one returns
//! the code it has determined at creation time
-class MoniTool_Element : public MMgt_TShared
+class MoniTool_Element : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(MoniTool_Element,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(MoniTool_Element,Standard_Transient)
protected:
#include <MoniTool_IntVal.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(MoniTool_IntVal,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(MoniTool_IntVal,Standard_Transient)
MoniTool_IntVal::MoniTool_IntVal (const Standard_Integer val) { theval = val; }
#include <Standard_Type.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class MoniTool_IntVal;
-DEFINE_STANDARD_HANDLE(MoniTool_IntVal, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(MoniTool_IntVal, Standard_Transient)
//! An Integer through a Handle (i.e. managed as TShared)
-class MoniTool_IntVal : public MMgt_TShared
+class MoniTool_IntVal : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(MoniTool_IntVal,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(MoniTool_IntVal,Standard_Transient)
protected:
#include <MoniTool_RealVal.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(MoniTool_RealVal,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(MoniTool_RealVal,Standard_Transient)
MoniTool_RealVal::MoniTool_RealVal (const Standard_Real val) { theval = val; }
#include <Standard_Type.hxx>
#include <Standard_Real.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class MoniTool_RealVal;
-DEFINE_STANDARD_HANDLE(MoniTool_RealVal, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(MoniTool_RealVal, Standard_Transient)
//! A Real through a Handle (i.e. managed as TShared)
-class MoniTool_RealVal : public MMgt_TShared
+class MoniTool_RealVal : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(MoniTool_RealVal,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(MoniTool_RealVal,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TCollection_AsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(MoniTool_SignText,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(MoniTool_SignText,Standard_Transient)
TCollection_AsciiString MoniTool_SignText::TextAlone
(const Handle(Standard_Transient)& ent) const
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
class TCollection_AsciiString;
class Standard_Transient;
class MoniTool_SignText;
-DEFINE_STANDARD_HANDLE(MoniTool_SignText, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(MoniTool_SignText, Standard_Transient)
//! Provides the basic service to get a text which identifies
//! an object in a context
//! It can be used for other classes (general signatures ...)
//! It can also be used to build a message in which an object
//! is to be identified
-class MoniTool_SignText : public MMgt_TShared
+class MoniTool_SignText : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(MoniTool_SignText,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(MoniTool_SignText,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <stdio.h>
-IMPLEMENT_STANDARD_RTTIEXT(MoniTool_Timer,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(MoniTool_Timer,Standard_Transient)
//=======================================================================
//function : Dump
#include <OSD_Timer.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_OStream.hxx>
#include <Standard_CString.hxx>
#include <MoniTool_DataMapOfTimer.hxx>
class MoniTool_Timer;
-DEFINE_STANDARD_HANDLE(MoniTool_Timer, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(MoniTool_Timer, Standard_Transient)
//! Provides convenient service on global timers
//! accessed by string name, mostly aimed for debugging purposes
//!
//! As a tool, supports static dictionary of timers
//! and provides static methods to easily access them
-class MoniTool_Timer : public MMgt_TShared
+class MoniTool_Timer : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(MoniTool_Timer,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(MoniTool_Timer,Standard_Transient)
protected:
#include <TCollection_HAsciiString.hxx>
#include <stdio.h>
-IMPLEMENT_STANDARD_RTTIEXT(MoniTool_TypedValue,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(MoniTool_TypedValue,Standard_Transient)
// Not Used :
//static char defmess[30];
#include <TColStd_HArray1OfAsciiString.hxx>
#include <MoniTool_ValueInterpret.hxx>
#include <MoniTool_ValueSatisfies.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
#include <Standard_Boolean.hxx>
#include <TColStd_HSequenceOfAsciiString.hxx>
class MoniTool_TypedValue;
-DEFINE_STANDARD_HANDLE(MoniTool_TypedValue, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(MoniTool_TypedValue, Standard_Transient)
//! This class allows to dynamically manage .. typed values, i.e.
//! values which have an alphanumeric expression, but with
//! Its string content, which is a Handle(HAsciiString) can be
//! shared by other data structures, hence gives a direct on line
//! access to its value.
-class MoniTool_TypedValue : public MMgt_TShared
+class MoniTool_TypedValue : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(MoniTool_TypedValue,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(MoniTool_TypedValue,Standard_Transient)
protected:
#include <iomanip>
-IMPLEMENT_STANDARD_RTTIEXT(NCollection_BaseAllocator,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(NCollection_BaseAllocator,Standard_Transient)
//=======================================================================
//function : Allocate
#ifndef NCollection_BaseAllocator_HeaderFile
#define NCollection_BaseAllocator_HeaderFile
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Type.hxx>
#include <NCollection_TypeDef.hxx>
* CommonBaseAllocator.
* Note that this object is managed by Handle.
*/
-class NCollection_BaseAllocator : public MMgt_TShared
+class NCollection_BaseAllocator : public Standard_Transient
{
public:
// ---------- PUBLIC METHODS ------------
public:
// ---------- CasCade RunTime Type Information
- DEFINE_STANDARD_RTTIEXT(NCollection_BaseAllocator,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(NCollection_BaseAllocator,Standard_Transient)
};
-DEFINE_STANDARD_HANDLE(NCollection_BaseAllocator,MMgt_TShared)
+DEFINE_STANDARD_HANDLE(NCollection_BaseAllocator,Standard_Transient)
#endif
#include <Standard_Type.hxx>
#include <NCollection_DefineArray1.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
// Declaration of Array1 class managed by Handle
#define DEFINE_HARRAY1(HClassName, _Array1Type_) \
-class HClassName : public _Array1Type_, public MMgt_TShared { \
+class HClassName : public _Array1Type_, public Standard_Transient { \
public: \
DEFINE_STANDARD_ALLOC \
DEFINE_NCOLLECTION_ALLOC \
HClassName (const _Array1Type_& theOther) : _Array1Type_(theOther) {} \
const _Array1Type_& Array1 () const { return *this; } \
_Array1Type_& ChangeArray1 () { return *this; } \
- DEFINE_STANDARD_RTTI_INLINE(HClassName,MMgt_TShared) \
+ DEFINE_STANDARD_RTTI_INLINE(HClassName,Standard_Transient) \
}; \
-DEFINE_STANDARD_HANDLE (HClassName, MMgt_TShared)
+DEFINE_STANDARD_HANDLE (HClassName, Standard_Transient)
#define IMPLEMENT_HARRAY1(HClassName)
#include <Standard_Type.hxx>
#include <NCollection_DefineArray2.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
// Declaration of Array2 class managed by Handle
#define DEFINE_HARRAY2(HClassName, _Array2Type_) \
-class HClassName : public _Array2Type_, public MMgt_TShared { \
+class HClassName : public _Array2Type_, public Standard_Transient { \
public: \
DEFINE_STANDARD_ALLOC \
DEFINE_NCOLLECTION_ALLOC \
HClassName (const _Array2Type_& theOther) : _Array2Type_(theOther) {} \
const _Array2Type_& Array2 () const { return *this; } \
_Array2Type_& ChangeArray2 () { return *this; } \
- DEFINE_STANDARD_RTTI_INLINE(HClassName,MMgt_TShared) \
+ DEFINE_STANDARD_RTTI_INLINE(HClassName,Standard_Transient) \
}; \
-DEFINE_STANDARD_HANDLE (HClassName, MMgt_TShared)
+DEFINE_STANDARD_HANDLE (HClassName, Standard_Transient)
#define IMPLEMENT_HARRAY2(HClassName)
#include <Standard_Type.hxx>
#include <NCollection_DefineSequence.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
// Declaration of Sequence class managed by Handle
#define DEFINE_HSEQUENCE(HClassName, _SequenceType_) \
-class HClassName : public _SequenceType_, public MMgt_TShared { \
+class HClassName : public _SequenceType_, public Standard_Transient { \
public: \
DEFINE_STANDARD_ALLOC \
DEFINE_NCOLLECTION_ALLOC \
typename std::enable_if<std::is_base_of<HClassName, T>::value>::type * = 0) { \
_SequenceType_::Append (theOther->ChangeSequence()); \
} \
- DEFINE_STANDARD_RTTI_INLINE(HClassName,MMgt_TShared) \
+ DEFINE_STANDARD_RTTI_INLINE(HClassName,Standard_Transient) \
}; \
-DEFINE_STANDARD_HANDLE (HClassName, MMgt_TShared)
+DEFINE_STANDARD_HANDLE (HClassName, Standard_Transient)
#define IMPLEMENT_HSEQUENCE(HClassName)
#include <NCollection_UBTree.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <NCollection_List.hxx>
#include <TColStd_SequenceOfInteger.hxx>
#include <NCollection_DataMap.hxx>
#ifndef NCollection_Handle_HeaderFile
#define NCollection_Handle_HeaderFile
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
+#include <Standard_Handle.hxx>
//! Purpose: This template class is used to define Handle adaptor
//! for allocated dynamically objects of arbitrary type.
//! Handle(Standard_Transient) in OCCT components.
template <class T>
-class NCollection_Handle : public Handle(Standard_Transient)
+class NCollection_Handle : public opencascade::handle<Standard_Transient>
{
private:
public:
//! Constructor: stores pointer to the object
- Ptr (T* theObj) { myPtr = theObj; }
+ Ptr (T* theObj) : myPtr (theObj) {}
//! Destructor deletes the object
~Ptr () { if ( myPtr ) delete myPtr; myPtr = 0; }
//! Note that additional argument is used to avoid ambiguity with
//! public constructor from pointer when Handle is intilialized by 0.
NCollection_Handle (Ptr* thePtr, int)
- : Handle(Standard_Transient) (thePtr) {}
+ : opencascade::handle<Standard_Transient> (thePtr) {}
public:
//! Constructor of handle from pointer on newly allocated object
NCollection_Handle (T* theObject)
- : Handle(Standard_Transient) (theObject ? new Ptr (theObject) : 0) {}
+ : opencascade::handle<Standard_Transient> (theObject ? new Ptr (theObject) : 0) {}
//! Cast handle to contained type
- T* get () { return ((Ptr*)Handle(Standard_Transient)::get())->myPtr; }
+ T* get () { return ((Ptr*)opencascade::handle<Standard_Transient>::get())->myPtr; }
//! Cast handle to contained type
- const T* get () const { return ((Ptr*)Handle(Standard_Transient)::get())->myPtr; }
+ const T* get () const { return ((Ptr*)opencascade::handle<Standard_Transient>::get())->myPtr; }
//! Cast handle to contained type
T* operator -> () { return get(); }
//! Downcast arbitrary Handle to the argument type if contained
//! object is Handle for this type; returns null otherwise
- static NCollection_Handle<T> DownCast (const Handle(Standard_Transient)& theOther)
+ static NCollection_Handle<T> DownCast (const opencascade::handle<Standard_Transient>& theOther)
{
return NCollection_Handle<T>(dynamic_cast<Ptr*>(theOther.get()), 0);
}
* _HUBTREE - the desired name of handled class
* _OBJTYPE - the name of the object type
* _BNDTYPE - the name of the bounding box type
- * _HPARENT - the name of parent class (usually MMgt_TShared)
+ * _HPARENT - the name of parent class (usually Standard_Transient)
*/
#define DEFINE_HUBTREE(_HUBTREE, _OBJTYPE, _BNDTYPE, _HPARENT) \
class _HUBTREE : public _HPARENT \
#include <Plate_D3.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(NLPlate_HGPPConstraint,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(NLPlate_HGPPConstraint,Standard_Transient)
void NLPlate_HGPPConstraint::SetUVFreeSliding(const Standard_Boolean)
{
#include <gp_XY.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Real.hxx>
class gp_XY;
class NLPlate_HGPPConstraint;
-DEFINE_STANDARD_HANDLE(NLPlate_HGPPConstraint, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(NLPlate_HGPPConstraint, Standard_Transient)
//! define a PinPoint geometric Constraint used to load a Non Linear Plate
-class NLPlate_HGPPConstraint : public MMgt_TShared
+class NLPlate_HGPPConstraint : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(NLPlate_HGPPConstraint,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(NLPlate_HGPPConstraint,Standard_Transient)
protected:
#ifndef _OpenGl_View_Header
#define _OpenGl_View_Header
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Type.hxx>
#include <TColStd_Array2OfReal.hxx>
#include <TCollection_ExtendedString.hxx>
#include <Graphic3d_GraphicDriver.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Window,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Window,Standard_Transient)
#if defined(HAVE_EGL)
#include <EGL/egl.h>
#include <Aspect_Window.hxx>
#include <OpenGl_GlCore11.hxx>
#include <OpenGl_Caps.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#if defined(__APPLE__)
#import <TargetConditionals.h>
class OpenGl_GraphicDriver;
class OpenGl_Window;
-DEFINE_STANDARD_HANDLE(OpenGl_Window,MMgt_TShared)
+DEFINE_STANDARD_HANDLE(OpenGl_Window,Standard_Transient)
//! This class represents low-level wrapper over window with GL context.
//! The window itself should be provided to constructor.
-class OpenGl_Window : public MMgt_TShared
+class OpenGl_Window : public Standard_Transient
{
public:
public:
- DEFINE_STANDARD_RTTIEXT(OpenGl_Window,MMgt_TShared) // Type definition
+ DEFINE_STANDARD_RTTIEXT(OpenGl_Window,Standard_Transient) // Type definition
DEFINE_STANDARD_ALLOC
};
#include <PLib_Base.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(PLib_Base,MMgt_TShared)
\ No newline at end of file
+IMPLEMENT_STANDARD_RTTIEXT(PLib_Base,Standard_Transient)
\ No newline at end of file
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <Standard_Real.hxx>
class PLib_Base;
-DEFINE_STANDARD_HANDLE(PLib_Base, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(PLib_Base, Standard_Transient)
//! To work with different polynomial's Bases
-class PLib_Base : public MMgt_TShared
+class PLib_Base : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(PLib_Base,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(PLib_Base,Standard_Transient)
protected:
#include <Standard_NullObject.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Poly_Polygon2D,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Poly_Polygon2D,Standard_Transient)
//=======================================================================
//function : Poly_Polygon2D
#include <Standard_Real.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
class Standard_NullObject;
class Poly_Polygon2D;
-DEFINE_STANDARD_HANDLE(Poly_Polygon2D, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Poly_Polygon2D, Standard_Transient)
//! Provides a polygon in 2D space (for example, in the
//! parametric space of a surface). It is generally an
//! A Polygon2D is defined by a table of nodes. Each node is
//! a 2D point. If the polygon is closed, the point of closure is
//! repeated at the end of the table of nodes.
-class Poly_Polygon2D : public MMgt_TShared
+class Poly_Polygon2D : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Poly_Polygon2D,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Poly_Polygon2D,Standard_Transient)
protected:
#include <Standard_NullObject.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Poly_Polygon3D,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Poly_Polygon3D,Standard_Transient)
//=======================================================================
//function : Poly_Polygon3D
#include <Standard_Real.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColStd_HArray1OfReal.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
class Poly_Polygon3D;
-DEFINE_STANDARD_HANDLE(Poly_Polygon3D, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Poly_Polygon3D, Standard_Transient)
//! This class Provides a polygon in 3D space. It is generally an approximate representation of a curve.
//! A Polygon3D is defined by a table of nodes. Each node is
//! If the polygon is an approximate representation of a curve,
//! you can associate with each of its nodes the value of the
//! parameter of the corresponding point on the curve.
-class Poly_Polygon3D : public MMgt_TShared
+class Poly_Polygon3D : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Poly_Polygon3D,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Poly_Polygon3D,Standard_Transient)
protected:
#include <Standard_NullObject.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Poly_PolygonOnTriangulation,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Poly_PolygonOnTriangulation,Standard_Transient)
//=======================================================================
//function : Poly_PolygonOnTriangulation
#include <Standard_Real.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <TColStd_HArray1OfReal.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
class Poly_PolygonOnTriangulation;
-DEFINE_STANDARD_HANDLE(Poly_PolygonOnTriangulation, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Poly_PolygonOnTriangulation, Standard_Transient)
//! This class provides a polygon in 3D space, based on the triangulation
//! of a surface. It may be the approximate representation of a
//! on a surface, you can associate with each of its nodes the
//! value of the parameter of the corresponding point on the
//! curve.represents a 3d Polygon
-class Poly_PolygonOnTriangulation : public MMgt_TShared
+class Poly_PolygonOnTriangulation : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Poly_PolygonOnTriangulation,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Poly_PolygonOnTriangulation,Standard_Transient)
protected:
#include <Standard_NullObject.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT (Poly_Triangulation, MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT (Poly_Triangulation, Standard_Transient)
//=======================================================================
//function : Poly_Triangulation
#include <TColgp_HArray1OfPnt2d.hxx>
#include <Poly_Array1OfTriangle.hxx>
#include <TShort_HArray1OfShortReal.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TShort_Array1OfShortReal.hxx>
class Poly_Triangulation;
-DEFINE_STANDARD_HANDLE(Poly_Triangulation, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Poly_Triangulation, Standard_Transient)
//! Provides a triangulation for a surface, a set of surfaces, or
//! more generally a shape.
//! representation induces simpler and more robust adjusting,
//! faster performances, and the results are as good.
//! This is a Transient class.
-class Poly_Triangulation : public MMgt_TShared
+class Poly_Triangulation : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Poly_Triangulation, MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Poly_Triangulation, Standard_Transient)
//! Constructs a triangulation from a set of triangles. The
//! triangulation is initialized without a triangle or a node, but capable of
#include <Prs3d_VertexDrawMode.hxx>
#include <Prs3d_DimensionUnits.hxx>
#include <Prs3d_TypeOfHLR.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class Prs3d_IsoAspect;
class Prs3d_LineAspect;
#include <Prs3d_Projector.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Prs3d_Projector,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Prs3d_Projector,Standard_Transient)
Prs3d_Projector::Prs3d_Projector (const HLRAlgo_Projector& HLPr): MyProjector(HLPr)
{}
#include <Standard_Type.hxx>
#include <HLRAlgo_Projector.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
class Prs3d_Projector;
-DEFINE_STANDARD_HANDLE(Prs3d_Projector, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Prs3d_Projector, Standard_Transient)
//! A projector object.
//! This object defines the parameters of a view for a
//! visualization algorithm. It is, for example, used by the
//! hidden line removal algorithms.
-class Prs3d_Projector : public MMgt_TShared
+class Prs3d_Projector : public Standard_Transient
{
public:
//! Returns a projector object for use in a hidden line removal algorithm.
Standard_EXPORT HLRAlgo_Projector Projector() const;
- DEFINE_STANDARD_RTTIEXT(Prs3d_Projector,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Prs3d_Projector,Standard_Transient)
private:
}
// Inherited field : item
- Handle(MMgt_TShared) aItem;
- data->ReadEntity(num, 3,"item", ach, STANDARD_TYPE(MMgt_TShared), aItem);
+ Handle(Standard_Transient) aItem;
+ data->ReadEntity(num, 3,"item", ach, STANDARD_TYPE(Standard_Transient), aItem);
// Initialisation of the read entity
ent->Init(aName, aStyles, aItem);
}
// Inherited field : item
- Handle(MMgt_TShared) aItem;
- data->ReadEntity(num, 2, "item", ach, STANDARD_TYPE(MMgt_TShared), aItem);
+ Handle(Standard_Transient) aItem;
+ data->ReadEntity(num, 2, "item", ach, STANDARD_TYPE(Standard_Transient), aItem);
// Initialization of the read entity
ent->Init(aName, aStyles, aItem);
}
// Inherited field : item
- Handle(MMgt_TShared) aItem;
- data->ReadEntity(num, 3, "item", ach, STANDARD_TYPE(MMgt_TShared), aItem);
+ Handle(Standard_Transient) aItem;
+ data->ReadEntity(num, 3, "item", ach, STANDARD_TYPE(Standard_Transient), aItem);
// Own field : fill_style_target
Handle(StepGeom_GeometricRepresentationItem) aFillStyleTarget;
}
// Inherited field : item
- Handle(MMgt_TShared) aItem;
- data->ReadEntity(num, 3,"item", ach, STANDARD_TYPE(MMgt_TShared), aItem);
+ Handle(Standard_Transient) aItem;
+ data->ReadEntity(num, 3,"item", ach, STANDARD_TYPE(Standard_Transient), aItem);
// Initialisation of the read entity
ent->Init(aName, aStyles, aItem);
}
// Inherited field : item
- Handle(MMgt_TShared) aItem;
- data->ReadEntity(num, 3,"item", ach, STANDARD_TYPE(MMgt_TShared), aItem);
+ Handle(Standard_Transient) aItem;
+ data->ReadEntity(num, 3,"item", ach, STANDARD_TYPE(Standard_Transient), aItem);
// Own field: elements
Handle(StepVisual_HArray1OfAnnotationPlaneElement) anElements;
// --- inherited field : item ---
- Handle(MMgt_TShared) aItem;
- data->ReadEntity(num, 3,"item", ach, STANDARD_TYPE(MMgt_TShared), aItem);
+ Handle(Standard_Transient) aItem;
+ data->ReadEntity(num, 3,"item", ach, STANDARD_TYPE(Standard_Transient), aItem);
// --- inherited field : overRiddenStyle ---
// --- inherited field : item ---
- Handle(MMgt_TShared) aItem;
- data->ReadEntity(num, 3,"item", ach, STANDARD_TYPE(MMgt_TShared), aItem);
+ Handle(Standard_Transient) aItem;
+ data->ReadEntity(num, 3,"item", ach, STANDARD_TYPE(Standard_Transient), aItem);
// --- own field : overRiddenStyle ---
// --- own field : item ---
- Handle(MMgt_TShared) aItem;
- data->ReadEntity(num, 3,"item", ach, STANDARD_TYPE(MMgt_TShared), aItem);
+ Handle(Standard_Transient) aItem;
+ data->ReadEntity(num, 3,"item", ach, STANDARD_TYPE(Standard_Transient), aItem);
//--- Initialisation of the read entity ---
}
// Inherited field : item
- Handle(MMgt_TShared) aItem;
- data->ReadEntity(num, 3,"item", ach, STANDARD_TYPE(MMgt_TShared), aItem);
+ Handle(Standard_Transient) aItem;
+ data->ReadEntity(num, 3,"item", ach, STANDARD_TYPE(Standard_Transient), aItem);
// Initialisation of the read entity
ent->Init(aName, aStyles, aItem);
#include <algorithm>
#include <errno.h>
-IMPLEMENT_STANDARD_RTTIEXT(Resource_Manager,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Resource_Manager,Standard_Transient)
//! Auxiliary enumeration for function WhatKindOfLine().
enum Resource_KindOfLine
#include <Resource_DataMapOfAsciiStringAsciiString.hxx>
#include <Resource_DataMapOfAsciiStringExtendedString.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
class Resource_Manager;
-DEFINE_STANDARD_HANDLE(Resource_Manager, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Resource_Manager, Standard_Transient)
//! Defines a resource structure and its management methods.
-class Resource_Manager : public MMgt_TShared
+class Resource_Manager : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Resource_Manager,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Resource_Manager,Standard_Transient)
protected:
#include <TDF_Label.hxx>
#include <XSControl_WorkSession.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(STEPCAFControl_ExternFile,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(STEPCAFControl_ExternFile,Standard_Transient)
//=======================================================================
//function : STEPCAFControl_ExternFile
#include <IFSelect_ReturnStatus.hxx>
#include <Standard_Boolean.hxx>
#include <TDF_Label.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class XSControl_WorkSession;
class TCollection_HAsciiString;
class TDF_Label;
class STEPCAFControl_ExternFile;
-DEFINE_STANDARD_HANDLE(STEPCAFControl_ExternFile, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(STEPCAFControl_ExternFile, Standard_Transient)
//! Auxiliary class serving as container for data resulting
//! from translation of external file
-class STEPCAFControl_ExternFile : public MMgt_TShared
+class STEPCAFControl_ExternFile : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(STEPCAFControl_ExternFile,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(STEPCAFControl_ExternFile,Standard_Transient)
protected:
continue;
// find shape
- NCollection_Vector<Handle(MMgt_TShared)> anItems;
+ NCollection_Vector<Handle(Standard_Transient)> anItems;
if (!style->Item().IsNull()) {
anItems.Append(style->Item());
}
#include <STEPSelections_AssemblyComponent.hxx>
#include <StepShape_ShapeDefinitionRepresentation.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(STEPSelections_AssemblyComponent,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(STEPSelections_AssemblyComponent,Standard_Transient)
STEPSelections_AssemblyComponent::STEPSelections_AssemblyComponent()
{
#include <Standard_Type.hxx>
#include <STEPSelections_HSequenceOfAssemblyLink.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepShape_ShapeDefinitionRepresentation;
class STEPSelections_AssemblyComponent;
-DEFINE_STANDARD_HANDLE(STEPSelections_AssemblyComponent, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(STEPSelections_AssemblyComponent, Standard_Transient)
-class STEPSelections_AssemblyComponent : public MMgt_TShared
+class STEPSelections_AssemblyComponent : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(STEPSelections_AssemblyComponent,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(STEPSelections_AssemblyComponent,Standard_Transient)
protected:
#include <STEPSelections_AssemblyComponent.hxx>
#include <STEPSelections_AssemblyLink.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(STEPSelections_AssemblyLink,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(STEPSelections_AssemblyLink,Standard_Transient)
STEPSelections_AssemblyLink::STEPSelections_AssemblyLink()
{
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepRepr_NextAssemblyUsageOccurrence;
class Standard_Transient;
class STEPSelections_AssemblyComponent;
class STEPSelections_AssemblyLink;
-DEFINE_STANDARD_HANDLE(STEPSelections_AssemblyLink, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(STEPSelections_AssemblyLink, Standard_Transient)
-class STEPSelections_AssemblyLink : public MMgt_TShared
+class STEPSelections_AssemblyLink : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(STEPSelections_AssemblyLink,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(STEPSelections_AssemblyLink,Standard_Transient)
protected:
#include <SelectMgr_Filter.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(SelectMgr_Filter,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(SelectMgr_Filter,Standard_Transient)
Standard_Boolean SelectMgr_Filter::ActsOn(const TopAbs_ShapeEnum /*aStandardMode*/) const
{return Standard_False;}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <TopAbs_ShapeEnum.hxx>
class SelectMgr_EntityOwner;
class SelectMgr_Filter;
-DEFINE_STANDARD_HANDLE(SelectMgr_Filter, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(SelectMgr_Filter, Standard_Transient)
//! The root class to define filter objects for selection.
//! Advance handling of objects requires the services of
//! You can create your own filters by defining new filter
//! classes inheriting this framework. You use these
//! filters by loading them into an AIS interactive context.
-class SelectMgr_Filter : public MMgt_TShared
+class SelectMgr_Filter : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(SelectMgr_Filter,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(SelectMgr_Filter,Standard_Transient)
protected:
#include <SelectBasics_EntityOwner.hxx>
#include <SelectMgr_Selection.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(SelectMgr_Selection,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(SelectMgr_Selection,Standard_Transient)
//==================================================
// Function: SelectMgr_Selection
#include <Standard_Type.hxx>
#include <SelectMgr_TypeOfUpdate.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <SelectMgr_SensitiveEntity.hxx>
#include <SelectMgr_StateOfSelection.hxx>
#include <SelectMgr_TypeOfBVHUpdate.hxx>
//! - mode 4 : selection of the faces
//! - mode 5 : selection of the shells
//! - mode 6 : selection of the constituent solids.
-class SelectMgr_Selection : public MMgt_TShared
+class SelectMgr_Selection : public Standard_Transient
{
public:
//! proper updates use SelectMgr_SelectionManager::SetSelectionSensitivity method.
Standard_EXPORT void SetSensitivity (const Standard_Integer theNewSens);
- DEFINE_STANDARD_RTTIEXT(SelectMgr_Selection,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(SelectMgr_Selection,Standard_Transient)
protected:
Standard_Boolean myIsCustomSens;
};
-DEFINE_STANDARD_HANDLE(SelectMgr_Selection, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(SelectMgr_Selection, Standard_Transient)
#include <SelectMgr_Selection.lxx>
#include <TColStd_ListOfInteger.hxx>
#include <TColStd_MapIteratorOfMapOfTransient.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(SelectMgr_SelectionManager,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(SelectMgr_SelectionManager,Standard_Transient)
static Standard_Integer FindIndex (const SelectMgr_SequenceOfSelector& theSelectorsSeq,
const Handle(SelectMgr_ViewerSelector)& theSelector)
#include <TColStd_MapOfTransient.hxx>
#include <SelectMgr_DataMapOfObjectSelectors.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <SelectMgr_ViewerSelector.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
class SelectMgr_SelectionManager;
-DEFINE_STANDARD_HANDLE(SelectMgr_SelectionManager, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(SelectMgr_SelectionManager, Standard_Transient)
//! A framework to manage selection from the point of
//! view of viewer selectors. These can be added and
//! removed, and selection modes can be activated and
//! deactivated. In addition, objects may be known to all
//! selectors or only to some.
-class SelectMgr_SelectionManager : public MMgt_TShared
+class SelectMgr_SelectionManager : public Standard_Transient
{
public:
//! Re-adds selectable object in BVHs in all viewer selectors.
Standard_EXPORT void UpdateSelection (const Handle(SelectMgr_SelectableObject)& theObj);
- DEFINE_STANDARD_RTTIEXT(SelectMgr_SelectionManager,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(SelectMgr_SelectionManager,Standard_Transient)
protected:
//! BVH traverse;
//! 2. if tolerance of sensitive entity is less than mytolerance, the frustum for
//! intersection detection will be resized according to its sensitivity.
-class SelectMgr_ViewerSelector : public MMgt_TShared
+class SelectMgr_ViewerSelector : public Standard_Transient
{
- DEFINE_STANDARD_RTTIEXT(SelectMgr_ViewerSelector, MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(SelectMgr_ViewerSelector, Standard_Transient)
friend class SelectMgr_SelectionManager;
public:
#include <TopoDS_Shape.hxx>
#include <TopoDS_Wire.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(ShapeAlgo_AlgoContainer,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(ShapeAlgo_AlgoContainer,Standard_Transient)
//=======================================================================
//function : ShapeAlgo_AlgoContainer
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Real.hxx>
#include <TColGeom_SequenceOfCurve.hxx>
class ShapeAlgo_AlgoContainer;
-DEFINE_STANDARD_HANDLE(ShapeAlgo_AlgoContainer, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(ShapeAlgo_AlgoContainer, Standard_Transient)
-class ShapeAlgo_AlgoContainer : public MMgt_TShared
+class ShapeAlgo_AlgoContainer : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(ShapeAlgo_AlgoContainer,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(ShapeAlgo_AlgoContainer,Standard_Transient)
protected:
#include <ShapeFix_Shape.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(ShapeAlgo_ToolContainer,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(ShapeAlgo_ToolContainer,Standard_Transient)
//=======================================================================
//function : ShapeAlgo_ToolContainer
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class ShapeFix_Shape;
class ShapeFix_EdgeProjAux;
class ShapeAlgo_ToolContainer;
-DEFINE_STANDARD_HANDLE(ShapeAlgo_ToolContainer, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(ShapeAlgo_ToolContainer, Standard_Transient)
//! Returns tools used by AlgoContainer
-class ShapeAlgo_ToolContainer : public MMgt_TShared
+class ShapeAlgo_ToolContainer : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(ShapeAlgo_ToolContainer,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(ShapeAlgo_ToolContainer,Standard_Transient)
protected:
#include <NCollection_UBTree.hxx>
#include <Bnd_Box.hxx>
#include <gp_Pnt.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TopTools_HArray1OfShape.hxx>
#include <ShapeExtend.hxx>
#include <TopoDS_Wire.hxx>
#include <TopTools_HSequenceOfShape.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(ShapeAnalysis_FreeBoundData,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(ShapeAnalysis_FreeBoundData,Standard_Transient)
//=======================================================================
//function : ShapeAnalysis_FreeBoundData
#include <Standard_Real.hxx>
#include <TopTools_HSequenceOfShape.hxx>
#include <TopTools_DataMapOfShapeReal.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
class TopoDS_Wire;
class ShapeAnalysis_FreeBoundData;
-DEFINE_STANDARD_HANDLE(ShapeAnalysis_FreeBoundData, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(ShapeAnalysis_FreeBoundData, Standard_Transient)
//! This class is intended to represent free bound and to store
//! its properties.
//!
//! This class provides methods for setting and getting fields
//! only.
-class ShapeAnalysis_FreeBoundData : public MMgt_TShared
+class ShapeAnalysis_FreeBoundData : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(ShapeAnalysis_FreeBoundData,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(ShapeAnalysis_FreeBoundData,Standard_Transient)
protected:
#include <Standard_NoSuchObject.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(ShapeAnalysis_Surface,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(ShapeAnalysis_Surface,Standard_Transient)
//S4135
//S4135
#include <gp_Pnt.hxx>
#include <gp_Pnt2d.hxx>
#include <Bnd_Box.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TColgp_SequenceOfPnt.hxx>
#include <TColgp_SequenceOfPnt2d.hxx>
class Geom_Surface;
class ShapeAnalysis_Surface;
-DEFINE_STANDARD_HANDLE(ShapeAnalysis_Surface, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(ShapeAnalysis_Surface, Standard_Transient)
//! Complements standard tool Geom_Surface by providing additional
//! functionality for detection surface singularities, checking
//! one is also provided.
//!
//! This tool is optimised: computes most information only once
-class ShapeAnalysis_Surface : public MMgt_TShared
+class ShapeAnalysis_Surface : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(ShapeAnalysis_Surface,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(ShapeAnalysis_Surface,Standard_Transient)
protected:
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(ShapeAnalysis_TransferParameters,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(ShapeAnalysis_TransferParameters,Standard_Transient)
//=======================================================================
//function : ShapeAnalysis_TransferParameters
#include <Standard_Real.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TColStd_HSequenceOfReal.hxx>
#include <Standard_Boolean.hxx>
class TopoDS_Edge;
class ShapeAnalysis_TransferParameters;
-DEFINE_STANDARD_HANDLE(ShapeAnalysis_TransferParameters, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(ShapeAnalysis_TransferParameters, Standard_Transient)
//! This tool is used for transferring parameters
//! from 3d curve of the edge to pcurve and vice versa.
//!
//! This behaviour can be redefined in derived classes, for example,
//! using projection.
-class ShapeAnalysis_TransferParameters : public MMgt_TShared
+class ShapeAnalysis_TransferParameters : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(ShapeAnalysis_TransferParameters,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(ShapeAnalysis_TransferParameters,Standard_Transient)
protected:
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_ListOfShape.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(ShapeAnalysis_Wire,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(ShapeAnalysis_Wire,Standard_Transient)
//szvsh addition
//=======================================================================
#include <TopoDS_Face.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <IntRes2d_SequenceOfIntersectionPoint.hxx>
#include <TColgp_SequenceOfPnt.hxx>
#endif
class ShapeAnalysis_Wire;
-DEFINE_STANDARD_HANDLE(ShapeAnalysis_Wire, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(ShapeAnalysis_Wire, Standard_Transient)
//! This class provides analysis of a wire to be compliant to
//! CAS.CADE requirements.
//!
//! In order to prepare an analyzer, it is necessary to load a wire,
//! set face and precision.
-class ShapeAnalysis_Wire : public MMgt_TShared
+class ShapeAnalysis_Wire : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(ShapeAnalysis_Wire,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(ShapeAnalysis_Wire,Standard_Transient)
protected:
#include <IntCurve_IntConicConic.hxx>
#include <algorithm>
-IMPLEMENT_STANDARD_RTTIEXT(ShapeConstruct_ProjectCurveOnSurface,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(ShapeConstruct_ProjectCurveOnSurface,Standard_Transient)
#define NCONTROL 23
#include <Standard_Integer.hxx>
#include <gp_Pnt.hxx>
#include <gp_Pnt2d.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <ShapeExtend_Status.hxx>
#include <GeomAbs_Shape.hxx>
#include <TColStd_Array1OfReal.hxx>
#endif
class ShapeConstruct_ProjectCurveOnSurface;
-DEFINE_STANDARD_HANDLE(ShapeConstruct_ProjectCurveOnSurface, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(ShapeConstruct_ProjectCurveOnSurface, Standard_Transient)
//! This tool provides a method for computing pcurve by projecting
//! 3d curve onto a surface.
//! until the condition is fulfilled).
//! Isoparametric cases (if curve corresponds to U=const or V=const on
//! the surface) are recognized with the given precision.
-class ShapeConstruct_ProjectCurveOnSurface : public MMgt_TShared
+class ShapeConstruct_ProjectCurveOnSurface : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(ShapeConstruct_ProjectCurveOnSurface,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(ShapeConstruct_ProjectCurveOnSurface,Standard_Transient)
protected:
#include <ShapeCustom_RestrictionParameters.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(ShapeCustom_RestrictionParameters,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(ShapeCustom_RestrictionParameters,Standard_Transient)
//=======================================================================
//function : ShapeCustom_RestrictionParameters
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class ShapeCustom_RestrictionParameters;
-DEFINE_STANDARD_HANDLE(ShapeCustom_RestrictionParameters, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(ShapeCustom_RestrictionParameters, Standard_Transient)
//! This class is axuluary tool which contains parameters for
//! BSplineRestriction class.
-class ShapeCustom_RestrictionParameters : public MMgt_TShared
+class ShapeCustom_RestrictionParameters : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(ShapeCustom_RestrictionParameters,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(ShapeCustom_RestrictionParameters,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TopoDS_Shape.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(ShapeExtend_BasicMsgRegistrator,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(ShapeExtend_BasicMsgRegistrator,Standard_Transient)
//=======================================================================
//function : ShapeExtend_BasicMsgRegistrator
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Message_Gravity.hxx>
class Standard_Transient;
class Message_Msg;
class ShapeExtend_BasicMsgRegistrator;
-DEFINE_STANDARD_HANDLE(ShapeExtend_BasicMsgRegistrator, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(ShapeExtend_BasicMsgRegistrator, Standard_Transient)
//! Abstract class that can be used for attaching messages
//! to the objects (e.g. shapes).
//! The methods of this class are empty and redefined, for instance,
//! in the classes for Data Exchange processors for attaching
//! messages to interface file entities or CAS.CADE shapes.
-class ShapeExtend_BasicMsgRegistrator : public MMgt_TShared
+class ShapeExtend_BasicMsgRegistrator : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(ShapeExtend_BasicMsgRegistrator,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(ShapeExtend_BasicMsgRegistrator,Standard_Transient)
protected:
#include <TopoDS_Wire.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(ShapeExtend_WireData,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(ShapeExtend_WireData,Standard_Transient)
//=======================================================================
//function : ShapeExtend_WireData
#include <TColStd_HSequenceOfInteger.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TopoDS_Wire;
class TopoDS_Edge;
class TopoDS_Shape;
class ShapeExtend_WireData;
-DEFINE_STANDARD_HANDLE(ShapeExtend_WireData, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(ShapeExtend_WireData, Standard_Transient)
//! This class provides a data structure necessary for work with the wire as with
//! ordered list of edges, what is required for many algorithms. The advantage of
//! Moreover, this class is stored as a field in other classes which are
//! they returned as results of functions, storing only a handle to
//! ShapeExtend_WireData saves time and memory.
-class ShapeExtend_WireData : public MMgt_TShared
+class ShapeExtend_WireData : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(ShapeExtend_WireData,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(ShapeExtend_WireData,Standard_Transient)
protected:
#include <TopoDS_Vertex.hxx>
#include <ShapeBuild_ReShape.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(ShapeFix_Edge,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(ShapeFix_Edge,Standard_Transient)
//=======================================================================
//function : ShapeFix_Edge
#include <Standard_Type.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Real.hxx>
#include <ShapeExtend_Status.hxx>
#endif
class ShapeFix_Edge;
-DEFINE_STANDARD_HANDLE(ShapeFix_Edge, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(ShapeFix_Edge, Standard_Transient)
//! Fixing invalid edge.
//! Geometrical and/or topological inconsistency:
//! - incorrect SameParameter flag (curve deviation is greater than
//! edge tolerance),
//! - not adjacent curves (3d or pcurve) to the vertices.
-class ShapeFix_Edge : public MMgt_TShared
+class ShapeFix_Edge : public Standard_Transient
{
public:
//! Returns context
Standard_EXPORT Handle(ShapeBuild_ReShape) Context() const;
- DEFINE_STANDARD_RTTIEXT(ShapeFix_Edge,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(ShapeFix_Edge,Standard_Transient)
protected:
#include <Adaptor3d_HCurve.hxx>
#include <BSplCLib.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(ShapeFix_EdgeProjAux,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(ShapeFix_EdgeProjAux,Standard_Transient)
//=======================================================================
//function : ShapeFix_EdgeProjAux
#include <TopoDS_Edge.hxx>
#include <Standard_Real.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TopoDS_Face;
class TopoDS_Edge;
class Geom2d_Curve;
class ShapeFix_EdgeProjAux;
-DEFINE_STANDARD_HANDLE(ShapeFix_EdgeProjAux, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(ShapeFix_EdgeProjAux, Standard_Transient)
//! Project 3D point (vertex) on pcurves to find Vertex Parameter
//! on parametric representation of an edge
-class ShapeFix_EdgeProjAux : public MMgt_TShared
+class ShapeFix_EdgeProjAux : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(ShapeFix_EdgeProjAux,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(ShapeFix_EdgeProjAux,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TopoDS_Shape.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(ShapeFix_Root,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(ShapeFix_Root,Standard_Transient)
//=======================================================================
//function : ShapeFix_Root
#include <Standard_Real.hxx>
#include <TopoDS_Shape.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Message_Gravity.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
class ShapeFix_Root;
-DEFINE_STANDARD_HANDLE(ShapeFix_Root, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(ShapeFix_Root, Standard_Transient)
//! Root class for fixing operations
//! Provides context for recording changes (optional),
//! basic precision value and limit (minimal and
//! maximal) values for tolerances,
//! and message registrator
-class ShapeFix_Root : public MMgt_TShared
+class ShapeFix_Root : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(ShapeFix_Root,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(ShapeFix_Root,Standard_Transient)
protected:
#include <TCollection_HAsciiString.hxx>
#include <sys/stat.h>
-IMPLEMENT_STANDARD_RTTIEXT(ShapeProcess_Context,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(ShapeProcess_Context,Standard_Transient)
//=======================================================================
//function : ShapeProcess_Context
#include <TColStd_HSequenceOfHAsciiString.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Real.hxx>
class ShapeProcess_Context;
-DEFINE_STANDARD_HANDLE(ShapeProcess_Context, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(ShapeProcess_Context, Standard_Transient)
//! Provides convenient interface to resource file
//! Allows to load resource file and get values of
//! if scope is defined as "ToV4" and requested parameter
//! is "exec.op", value of "ToV4.exec.op" parameter from
//! the resource file will be returned
-class ShapeProcess_Context : public MMgt_TShared
+class ShapeProcess_Context : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(ShapeProcess_Context,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(ShapeProcess_Context,Standard_Transient)
protected:
#include <ShapeProcess_Operator.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(ShapeProcess_Operator,MMgt_TShared)
\ No newline at end of file
+IMPLEMENT_STANDARD_RTTIEXT(ShapeProcess_Operator,Standard_Transient)
\ No newline at end of file
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
class ShapeProcess_Context;
class ShapeProcess_Operator;
-DEFINE_STANDARD_HANDLE(ShapeProcess_Operator, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(ShapeProcess_Operator, Standard_Transient)
//! Abstract Operator class providing a tool to
//! perform an operation on Context
-class ShapeProcess_Operator : public MMgt_TShared
+class ShapeProcess_Operator : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(ShapeProcess_Operator,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(ShapeProcess_Operator,Standard_Transient)
protected:
#include <TopoDS_Vertex.hxx>
#include <TopTools_DataMapOfShapeShape.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(ShapeUpgrade_RemoveLocations,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(ShapeUpgrade_RemoveLocations,Standard_Transient)
//#include <ShapeUpgrade_DataMapOfShapeListOfTransient.hxx>
//=======================================================================
#include <TopAbs_ShapeEnum.hxx>
#include <TopoDS_Shape.hxx>
#include <TopTools_DataMapOfShapeShape.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
class TopoDS_Shape;
class ShapeUpgrade_RemoveLocations;
-DEFINE_STANDARD_HANDLE(ShapeUpgrade_RemoveLocations, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(ShapeUpgrade_RemoveLocations, Standard_Transient)
//! Removes all locations sub-shapes of specified shape
-class ShapeUpgrade_RemoveLocations : public MMgt_TShared
+class ShapeUpgrade_RemoveLocations : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(ShapeUpgrade_RemoveLocations,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(ShapeUpgrade_RemoveLocations,Standard_Transient)
protected:
#include <TColStd_HSequenceOfReal.hxx>
#include <TColStd_ListIteratorOfListOfReal.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(ShapeUpgrade_SplitCurve,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(ShapeUpgrade_SplitCurve,Standard_Transient)
//=======================================================================
//function : ShapeUpgrade_SplitCurve
#include <TColStd_HSequenceOfReal.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Real.hxx>
#include <Standard_Boolean.hxx>
#include <ShapeExtend_Status.hxx>
#endif
class ShapeUpgrade_SplitCurve;
-DEFINE_STANDARD_HANDLE(ShapeUpgrade_SplitCurve, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(ShapeUpgrade_SplitCurve, Standard_Transient)
//! Splits a curve with a criterion.
-class ShapeUpgrade_SplitCurve : public MMgt_TShared
+class ShapeUpgrade_SplitCurve : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(ShapeUpgrade_SplitCurve,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(ShapeUpgrade_SplitCurve,Standard_Transient)
protected:
#include <TColStd_Array1OfReal.hxx>
#include <TColStd_HSequenceOfReal.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(ShapeUpgrade_SplitSurface,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(ShapeUpgrade_SplitSurface,Standard_Transient)
//=======================================================================
//function : ShapeUpgrade_SplitSurface
#include <TColStd_HSequenceOfReal.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Real.hxx>
#include <Standard_Boolean.hxx>
#include <ShapeExtend_Status.hxx>
#endif
class ShapeUpgrade_SplitSurface;
-DEFINE_STANDARD_HANDLE(ShapeUpgrade_SplitSurface, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(ShapeUpgrade_SplitSurface, Standard_Transient)
//! Splits a Surface with a criterion.
-class ShapeUpgrade_SplitSurface : public MMgt_TShared
+class ShapeUpgrade_SplitSurface : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(ShapeUpgrade_SplitSurface,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(ShapeUpgrade_SplitSurface,Standard_Transient)
protected:
#include <ShapeUpgrade_Tool.hxx>
#include <Standard_Type.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(ShapeUpgrade_Tool,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(ShapeUpgrade_Tool,Standard_Transient)
//=======================================================================
//function : ShapeUpgrade_Tool
#include <Standard_Type.hxx>
#include <Standard_Real.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class ShapeBuild_ReShape;
class ShapeUpgrade_Tool;
-DEFINE_STANDARD_HANDLE(ShapeUpgrade_Tool, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(ShapeUpgrade_Tool, Standard_Transient)
//! Tool is a root class for splitting classes
//! Provides context for recording changes, basic
//! precision value and limit (minimal and maximal)
//! values for tolerances
-class ShapeUpgrade_Tool : public MMgt_TShared
+class ShapeUpgrade_Tool : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(ShapeUpgrade_Tool,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(ShapeUpgrade_Tool,Standard_Transient)
protected:
#include <BRepAdaptor_Curve2d.hxx>
#include <gp_Vec2d.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(ShapeUpgrade_UnifySameDomain,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(ShapeUpgrade_UnifySameDomain,Standard_Transient)
struct SubSequenceOfEdges
{
#include <TopoDS_Shape.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TopTools_DataMapOfShapeShape.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
class ShapeUpgrade_UnifySameDomain;
-DEFINE_STANDARD_HANDLE(ShapeUpgrade_UnifySameDomain, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(ShapeUpgrade_UnifySameDomain, Standard_Transient)
//! This tool tries to unify faces and edges of the shape which lies on the same geometry.
//! Faces/edges considering as 'same-domain' if a group of neighbouring faces/edges lying on coincident surfaces/curves.
//! The algorithm provides a place holder for the history and collects the
//! history by default.
//! To avoid collecting of the history the place holder should be set to the null handle.
-class ShapeUpgrade_UnifySameDomain : public MMgt_TShared
+class ShapeUpgrade_UnifySameDomain : public Standard_Transient
{
public:
return myHistory;
}
- DEFINE_STANDARD_RTTIEXT(ShapeUpgrade_UnifySameDomain,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(ShapeUpgrade_UnifySameDomain,Standard_Transient)
protected:
#ifndef _StdStorage_Data_HeaderFile
#define _StdStorage_Data_HeaderFile
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Macro.hxx>
+#include <Standard_Handle.hxx>
+
class StdStorage_HeaderData;
class StdStorage_TypeData;
class StdStorage_RootData;
//! mechanism: external references are not
//! supported by Storage_Schema algorithm
class StdStorage_Data
- : public MMgt_TShared
+ : public Standard_Transient
{
public:
#include <TCollection_AsciiString.hxx>
#include <TCollection_ExtendedString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StdStorage_HeaderData, MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StdStorage_HeaderData, Standard_Transient)
StdStorage_HeaderData::StdStorage_HeaderData()
: myNBObj(0), myErrorStatus(Storage_VSOk)
#include <TColStd_SequenceOfAsciiString.hxx>
#include <TColStd_SequenceOfExtendedString.hxx>
#include <Storage_Error.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class Storage_BaseDriver;
class TCollection_AsciiString;
class TCollection_ExtendedString;
class StdStorage_HeaderData;
-DEFINE_STANDARD_HANDLE(StdStorage_HeaderData, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StdStorage_HeaderData, Standard_Transient)
//! Storage header data section that contains some
//! auxiliary information (application name, schema version,
//! creation date, comments and so on...)
class StdStorage_HeaderData
- : public MMgt_TShared
+ : public Standard_Transient
{
friend class StdStorage_Data;
public:
- DEFINE_STANDARD_RTTIEXT(StdStorage_HeaderData, MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StdStorage_HeaderData, Standard_Transient)
//! Reads the header data section from the container defined by theDriver.
//! Returns Standard_True in case of success. Otherwise, one need to get
#include <StdStorage_Root.hxx>
#include <TCollection_AsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StdStorage_Root, MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StdStorage_Root, Standard_Transient)
StdStorage_Root::StdStorage_Root()
: myRef(0)
#include <TCollection_AsciiString.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StdObjMgt_Persistent;
class Storage_Schema;
class TCollection_AsciiString;
class Storage_Root;
-DEFINE_STANDARD_HANDLE(StdStorage_Root, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StdStorage_Root, Standard_Transient)
//! Describes a named persistent root
class StdStorage_Root
- : public MMgt_TShared
+ : public Standard_Transient
{
friend class StdStorage_RootData;
public:
- DEFINE_STANDARD_RTTIEXT(StdStorage_Root, MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StdStorage_Root, Standard_Transient)
//! Creates an empty root
Standard_EXPORT StdStorage_Root();
#include <Storage_DataMapIteratorOfMapOfPers.hxx>
#include <TCollection_AsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StdStorage_RootData, MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StdStorage_RootData, Standard_Transient)
StdStorage_RootData::StdStorage_RootData()
: myErrorStatus(Storage_VSOk)
#include <Storage_Error.hxx>
#include <TCollection_AsciiString.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
#include <StdStorage_MapOfRoots.hxx>
class StdObjMgt_Persistent;
class StdStorage_RootData;
-DEFINE_STANDARD_HANDLE(StdStorage_RootData, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StdStorage_RootData, Standard_Transient)
//! Storage root data section contains root persistent objects
class StdStorage_RootData
- : public MMgt_TShared
+ : public Standard_Transient
{
friend class StdStorage_Data;
public:
- DEFINE_STANDARD_RTTIEXT(StdStorage_RootData, MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StdStorage_RootData, Standard_Transient)
//! Reads the root data section from the container defined by theDriver.
//! Returns Standard_True in case of success. Otherwise, one need to get
#include <Storage_StreamTypeMismatchError.hxx>
#include <TCollection_AsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StdStorage_TypeData, MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StdStorage_TypeData, Standard_Transient)
StdStorage_TypeData::StdStorage_TypeData()
: myTypeId(0),
#include <StdStorage_MapOfTypes.hxx>
#include <Storage_Error.hxx>
#include <TCollection_AsciiString.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
#include <StdObjMgt_MapOfInstantiators.hxx>
class TCollection_AsciiString;
class StdStorage_TypeData;
-DEFINE_STANDARD_HANDLE(StdStorage_TypeData, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StdStorage_TypeData, Standard_Transient)
//! Storage type data section keeps association between
//! persistent textual types and their numbers
class StdStorage_TypeData
- : public MMgt_TShared
+ : public Standard_Transient
{
friend class StdStorage_Data;
public:
- DEFINE_STANDARD_RTTIEXT(StdStorage_TypeData, MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StdStorage_TypeData, Standard_Transient)
//! Reads the type data section from the container defined by theDriver.
//! Returns Standard_True in case of success. Otherwise, one need to get
#include <StepAP242_IdAttribute.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepAP242_IdAttribute,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepAP242_IdAttribute,Standard_Transient)
//=======================================================================
//function : StepAP242_IdAttribute
#include <Standard_Type.hxx>
#include <StepAP242_IdAttributeSelect.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepAP242_IdAttributeSelect;
class StepAP242_IdAttribute;
-DEFINE_STANDARD_HANDLE(StepAP242_IdAttribute, MMgt_TShared)
-class StepAP242_IdAttribute : public MMgt_TShared
+DEFINE_STANDARD_HANDLE(StepAP242_IdAttribute, Standard_Transient)
+class StepAP242_IdAttribute : public Standard_Transient
{
public:
return identifiedItem;
}
- DEFINE_STANDARD_RTTIEXT(StepAP242_IdAttribute,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepAP242_IdAttribute,Standard_Transient)
private:
Handle(TCollection_HAsciiString) attributeValue;
#include <StepAP242_ItemIdentifiedRepresentationUsageDefinition.hxx>
#include <StepRepr_HArray1OfRepresentationItem.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepAP242_ItemIdentifiedRepresentationUsage,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepAP242_ItemIdentifiedRepresentationUsage,Standard_Transient)
//=======================================================================
//function : StepAP242_ItemIdentifiedRepresentationUsage
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <StepAP242_ItemIdentifiedRepresentationUsageDefinition.hxx>
#include <Standard_Integer.hxx>
#include <StepRepr_HArray1OfRepresentationItem.hxx>
class StepRepr_RepresentationItem;
class StepAP242_ItemIdentifiedRepresentationUsage;
-DEFINE_STANDARD_HANDLE(StepAP242_ItemIdentifiedRepresentationUsage, MMgt_TShared)
-class StepAP242_ItemIdentifiedRepresentationUsage : public MMgt_TShared
+DEFINE_STANDARD_HANDLE(StepAP242_ItemIdentifiedRepresentationUsage, Standard_Transient)
+class StepAP242_ItemIdentifiedRepresentationUsage : public Standard_Transient
{
public:
identifiedItem->SetValue (num, theItem);
}
- DEFINE_STANDARD_RTTIEXT(StepAP242_ItemIdentifiedRepresentationUsage,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepAP242_ItemIdentifiedRepresentationUsage,Standard_Transient)
private:
Handle(TCollection_HAsciiString) name;
#include <StepBasic_ActionMethod.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_Action,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_Action,Standard_Transient)
//=======================================================================
//function : StepBasic_Action
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_ActionMethod;
class StepBasic_Action;
-DEFINE_STANDARD_HANDLE(StepBasic_Action, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_Action, Standard_Transient)
//! Representation of STEP entity Action
-class StepBasic_Action : public MMgt_TShared
+class StepBasic_Action : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_Action,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_Action,Standard_Transient)
protected:
#include <StepBasic_Action.hxx>
#include <StepBasic_ActionAssignment.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ActionAssignment,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ActionAssignment,Standard_Transient)
//=======================================================================
//function : StepBasic_ActionAssignment
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_Action;
class StepBasic_ActionAssignment;
-DEFINE_STANDARD_HANDLE(StepBasic_ActionAssignment, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_ActionAssignment, Standard_Transient)
//! Representation of STEP entity ActionAssignment
-class StepBasic_ActionAssignment : public MMgt_TShared
+class StepBasic_ActionAssignment : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_ActionAssignment,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_ActionAssignment,Standard_Transient)
protected:
#include <StepBasic_ActionMethod.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ActionMethod,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ActionMethod,Standard_Transient)
//=======================================================================
//function : StepBasic_ActionMethod
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_ActionMethod;
-DEFINE_STANDARD_HANDLE(StepBasic_ActionMethod, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_ActionMethod, Standard_Transient)
//! Representation of STEP entity ActionMethod
-class StepBasic_ActionMethod : public MMgt_TShared
+class StepBasic_ActionMethod : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_ActionMethod,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_ActionMethod,Standard_Transient)
protected:
#include <StepBasic_ActionRequestAssignment.hxx>
#include <StepBasic_VersionedActionRequest.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ActionRequestAssignment,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ActionRequestAssignment,Standard_Transient)
//=======================================================================
//function : StepBasic_ActionRequestAssignment
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_VersionedActionRequest;
class StepBasic_ActionRequestAssignment;
-DEFINE_STANDARD_HANDLE(StepBasic_ActionRequestAssignment, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_ActionRequestAssignment, Standard_Transient)
//! Representation of STEP entity ActionRequestAssignment
-class StepBasic_ActionRequestAssignment : public MMgt_TShared
+class StepBasic_ActionRequestAssignment : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_ActionRequestAssignment,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_ActionRequestAssignment,Standard_Transient)
protected:
#include <StepBasic_ActionRequestSolution.hxx>
#include <StepBasic_VersionedActionRequest.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ActionRequestSolution,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ActionRequestSolution,Standard_Transient)
//=======================================================================
//function : StepBasic_ActionRequestSolution
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_ActionMethod;
class StepBasic_VersionedActionRequest;
class StepBasic_ActionRequestSolution;
-DEFINE_STANDARD_HANDLE(StepBasic_ActionRequestSolution, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_ActionRequestSolution, Standard_Transient)
//! Representation of STEP entity ActionRequestSolution
-class StepBasic_ActionRequestSolution : public MMgt_TShared
+class StepBasic_ActionRequestSolution : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_ActionRequestSolution,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_ActionRequestSolution,Standard_Transient)
protected:
#include <StepBasic_Address.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_Address,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_Address,Standard_Transient)
StepBasic_Address::StepBasic_Address () {}
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_Address;
-DEFINE_STANDARD_HANDLE(StepBasic_Address, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_Address, Standard_Transient)
-class StepBasic_Address : public MMgt_TShared
+class StepBasic_Address : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_Address,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_Address,Standard_Transient)
protected:
#include <StepBasic_ApplicationContext.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ApplicationContext,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ApplicationContext,Standard_Transient)
StepBasic_ApplicationContext::StepBasic_ApplicationContext () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_ApplicationContext;
-DEFINE_STANDARD_HANDLE(StepBasic_ApplicationContext, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_ApplicationContext, Standard_Transient)
-class StepBasic_ApplicationContext : public MMgt_TShared
+class StepBasic_ApplicationContext : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_ApplicationContext,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_ApplicationContext,Standard_Transient)
protected:
#include <StepBasic_ApplicationContextElement.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ApplicationContextElement,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ApplicationContextElement,Standard_Transient)
StepBasic_ApplicationContextElement::StepBasic_ApplicationContextElement () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_ApplicationContext;
class StepBasic_ApplicationContextElement;
-DEFINE_STANDARD_HANDLE(StepBasic_ApplicationContextElement, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_ApplicationContextElement, Standard_Transient)
-class StepBasic_ApplicationContextElement : public MMgt_TShared
+class StepBasic_ApplicationContextElement : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_ApplicationContextElement,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_ApplicationContextElement,Standard_Transient)
protected:
#include <StepBasic_ApplicationProtocolDefinition.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ApplicationProtocolDefinition,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ApplicationProtocolDefinition,Standard_Transient)
StepBasic_ApplicationProtocolDefinition::StepBasic_ApplicationProtocolDefinition () {}
#include <Standard_Type.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_ApplicationContext;
#endif
class StepBasic_ApplicationProtocolDefinition;
-DEFINE_STANDARD_HANDLE(StepBasic_ApplicationProtocolDefinition, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_ApplicationProtocolDefinition, Standard_Transient)
-class StepBasic_ApplicationProtocolDefinition : public MMgt_TShared
+class StepBasic_ApplicationProtocolDefinition : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_ApplicationProtocolDefinition,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_ApplicationProtocolDefinition,Standard_Transient)
protected:
#include <StepBasic_ApprovalStatus.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_Approval,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_Approval,Standard_Transient)
StepBasic_Approval::StepBasic_Approval () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_ApprovalStatus;
class TCollection_HAsciiString;
#endif
class StepBasic_Approval;
-DEFINE_STANDARD_HANDLE(StepBasic_Approval, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_Approval, Standard_Transient)
-class StepBasic_Approval : public MMgt_TShared
+class StepBasic_Approval : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_Approval,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_Approval,Standard_Transient)
protected:
#include <StepBasic_Approval.hxx>
#include <StepBasic_ApprovalAssignment.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ApprovalAssignment,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ApprovalAssignment,Standard_Transient)
void StepBasic_ApprovalAssignment::Init(
const Handle(StepBasic_Approval)& aAssignedApproval)
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_Approval;
class StepBasic_ApprovalAssignment;
-DEFINE_STANDARD_HANDLE(StepBasic_ApprovalAssignment, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_ApprovalAssignment, Standard_Transient)
-class StepBasic_ApprovalAssignment : public MMgt_TShared
+class StepBasic_ApprovalAssignment : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_ApprovalAssignment,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_ApprovalAssignment,Standard_Transient)
protected:
#include <StepBasic_ApprovalDateTime.hxx>
#include <StepBasic_DateTimeSelect.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ApprovalDateTime,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ApprovalDateTime,Standard_Transient)
StepBasic_ApprovalDateTime::StepBasic_ApprovalDateTime () { }
#include <Standard_Type.hxx>
#include <StepBasic_DateTimeSelect.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_Approval;
class StepBasic_DateTimeSelect;
class StepBasic_ApprovalDateTime;
-DEFINE_STANDARD_HANDLE(StepBasic_ApprovalDateTime, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_ApprovalDateTime, Standard_Transient)
//! Added from StepBasic Rev2 to Rev4
-class StepBasic_ApprovalDateTime : public MMgt_TShared
+class StepBasic_ApprovalDateTime : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_ApprovalDateTime,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_ApprovalDateTime,Standard_Transient)
protected:
#include <StepBasic_ApprovalRole.hxx>
#include <StepBasic_PersonOrganizationSelect.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ApprovalPersonOrganization,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ApprovalPersonOrganization,Standard_Transient)
StepBasic_ApprovalPersonOrganization::StepBasic_ApprovalPersonOrganization () {}
#include <Standard_Type.hxx>
#include <StepBasic_PersonOrganizationSelect.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_Approval;
class StepBasic_ApprovalRole;
class StepBasic_PersonOrganizationSelect;
class StepBasic_ApprovalPersonOrganization;
-DEFINE_STANDARD_HANDLE(StepBasic_ApprovalPersonOrganization, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_ApprovalPersonOrganization, Standard_Transient)
-class StepBasic_ApprovalPersonOrganization : public MMgt_TShared
+class StepBasic_ApprovalPersonOrganization : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_ApprovalPersonOrganization,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_ApprovalPersonOrganization,Standard_Transient)
protected:
#include <StepBasic_ApprovalRelationship.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ApprovalRelationship,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ApprovalRelationship,Standard_Transient)
StepBasic_ApprovalRelationship::StepBasic_ApprovalRelationship () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_Approval;
class StepBasic_ApprovalRelationship;
-DEFINE_STANDARD_HANDLE(StepBasic_ApprovalRelationship, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_ApprovalRelationship, Standard_Transient)
-class StepBasic_ApprovalRelationship : public MMgt_TShared
+class StepBasic_ApprovalRelationship : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_ApprovalRelationship,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_ApprovalRelationship,Standard_Transient)
protected:
#include <StepBasic_ApprovalRole.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ApprovalRole,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ApprovalRole,Standard_Transient)
StepBasic_ApprovalRole::StepBasic_ApprovalRole () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_ApprovalRole;
-DEFINE_STANDARD_HANDLE(StepBasic_ApprovalRole, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_ApprovalRole, Standard_Transient)
-class StepBasic_ApprovalRole : public MMgt_TShared
+class StepBasic_ApprovalRole : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_ApprovalRole,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_ApprovalRole,Standard_Transient)
protected:
#include <StepBasic_ApprovalStatus.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ApprovalStatus,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ApprovalStatus,Standard_Transient)
StepBasic_ApprovalStatus::StepBasic_ApprovalStatus () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_ApprovalStatus;
-DEFINE_STANDARD_HANDLE(StepBasic_ApprovalStatus, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_ApprovalStatus, Standard_Transient)
-class StepBasic_ApprovalStatus : public MMgt_TShared
+class StepBasic_ApprovalStatus : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_ApprovalStatus,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_ApprovalStatus,Standard_Transient)
protected:
#include <StepBasic_CertificationType.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_Certification,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_Certification,Standard_Transient)
//=======================================================================
//function : StepBasic_Certification
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_CertificationType;
class StepBasic_Certification;
-DEFINE_STANDARD_HANDLE(StepBasic_Certification, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_Certification, Standard_Transient)
//! Representation of STEP entity Certification
-class StepBasic_Certification : public MMgt_TShared
+class StepBasic_Certification : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_Certification,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_Certification,Standard_Transient)
protected:
#include <StepBasic_Certification.hxx>
#include <StepBasic_CertificationAssignment.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_CertificationAssignment,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_CertificationAssignment,Standard_Transient)
//=======================================================================
//function : StepBasic_CertificationAssignment
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_Certification;
class StepBasic_CertificationAssignment;
-DEFINE_STANDARD_HANDLE(StepBasic_CertificationAssignment, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_CertificationAssignment, Standard_Transient)
//! Representation of STEP entity CertificationAssignment
-class StepBasic_CertificationAssignment : public MMgt_TShared
+class StepBasic_CertificationAssignment : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_CertificationAssignment,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_CertificationAssignment,Standard_Transient)
protected:
#include <StepBasic_CertificationType.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_CertificationType,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_CertificationType,Standard_Transient)
//=======================================================================
//function : StepBasic_CertificationType
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_CertificationType;
-DEFINE_STANDARD_HANDLE(StepBasic_CertificationType, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_CertificationType, Standard_Transient)
//! Representation of STEP entity CertificationType
-class StepBasic_CertificationType : public MMgt_TShared
+class StepBasic_CertificationType : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_CertificationType,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_CertificationType,Standard_Transient)
protected:
#include <StepBasic_CharacterizedObject.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_CharacterizedObject,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_CharacterizedObject,Standard_Transient)
//=======================================================================
//function : StepBasic_CharacterizedObject
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_CharacterizedObject;
-DEFINE_STANDARD_HANDLE(StepBasic_CharacterizedObject, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_CharacterizedObject, Standard_Transient)
//! Representation of STEP entity CharacterizedObject
-class StepBasic_CharacterizedObject : public MMgt_TShared
+class StepBasic_CharacterizedObject : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_CharacterizedObject,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_CharacterizedObject,Standard_Transient)
protected:
#include <StepBasic_ContractType.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_Contract,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_Contract,Standard_Transient)
//=======================================================================
//function : StepBasic_Contract
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_ContractType;
class StepBasic_Contract;
-DEFINE_STANDARD_HANDLE(StepBasic_Contract, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_Contract, Standard_Transient)
//! Representation of STEP entity Contract
-class StepBasic_Contract : public MMgt_TShared
+class StepBasic_Contract : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_Contract,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_Contract,Standard_Transient)
protected:
#include <StepBasic_Contract.hxx>
#include <StepBasic_ContractAssignment.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ContractAssignment,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ContractAssignment,Standard_Transient)
//=======================================================================
//function : StepBasic_ContractAssignment
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_Contract;
class StepBasic_ContractAssignment;
-DEFINE_STANDARD_HANDLE(StepBasic_ContractAssignment, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_ContractAssignment, Standard_Transient)
//! Representation of STEP entity ContractAssignment
-class StepBasic_ContractAssignment : public MMgt_TShared
+class StepBasic_ContractAssignment : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_ContractAssignment,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_ContractAssignment,Standard_Transient)
protected:
#include <StepBasic_ContractType.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ContractType,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ContractType,Standard_Transient)
//=======================================================================
//function : StepBasic_ContractType
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_ContractType;
-DEFINE_STANDARD_HANDLE(StepBasic_ContractType, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_ContractType, Standard_Transient)
//! Representation of STEP entity ContractType
-class StepBasic_ContractType : public MMgt_TShared
+class StepBasic_ContractType : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_ContractType,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_ContractType,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <StepBasic_CoordinatedUniversalTimeOffset.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_CoordinatedUniversalTimeOffset,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_CoordinatedUniversalTimeOffset,Standard_Transient)
StepBasic_CoordinatedUniversalTimeOffset::StepBasic_CoordinatedUniversalTimeOffset () {}
#include <Standard_Integer.hxx>
#include <StepBasic_AheadOrBehind.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_CoordinatedUniversalTimeOffset;
-DEFINE_STANDARD_HANDLE(StepBasic_CoordinatedUniversalTimeOffset, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_CoordinatedUniversalTimeOffset, Standard_Transient)
-class StepBasic_CoordinatedUniversalTimeOffset : public MMgt_TShared
+class StepBasic_CoordinatedUniversalTimeOffset : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_CoordinatedUniversalTimeOffset,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_CoordinatedUniversalTimeOffset,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <StepBasic_Date.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_Date,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_Date,Standard_Transient)
StepBasic_Date::StepBasic_Date () {}
#include <Standard_Type.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_Date;
-DEFINE_STANDARD_HANDLE(StepBasic_Date, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_Date, Standard_Transient)
-class StepBasic_Date : public MMgt_TShared
+class StepBasic_Date : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_Date,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_Date,Standard_Transient)
protected:
#include <StepBasic_DateAndTime.hxx>
#include <StepBasic_LocalTime.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_DateAndTime,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_DateAndTime,Standard_Transient)
StepBasic_DateAndTime::StepBasic_DateAndTime () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_Date;
class StepBasic_LocalTime;
class StepBasic_DateAndTime;
-DEFINE_STANDARD_HANDLE(StepBasic_DateAndTime, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_DateAndTime, Standard_Transient)
-class StepBasic_DateAndTime : public MMgt_TShared
+class StepBasic_DateAndTime : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_DateAndTime,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_DateAndTime,Standard_Transient)
protected:
#include <StepBasic_DateAndTimeAssignment.hxx>
#include <StepBasic_DateTimeRole.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_DateAndTimeAssignment,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_DateAndTimeAssignment,Standard_Transient)
void StepBasic_DateAndTimeAssignment::Init(
const Handle(StepBasic_DateAndTime)& aAssignedDateAndTime,
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_DateAndTime;
class StepBasic_DateTimeRole;
class StepBasic_DateAndTimeAssignment;
-DEFINE_STANDARD_HANDLE(StepBasic_DateAndTimeAssignment, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_DateAndTimeAssignment, Standard_Transient)
-class StepBasic_DateAndTimeAssignment : public MMgt_TShared
+class StepBasic_DateAndTimeAssignment : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_DateAndTimeAssignment,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_DateAndTimeAssignment,Standard_Transient)
protected:
#include <StepBasic_DateAssignment.hxx>
#include <StepBasic_DateRole.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_DateAssignment,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_DateAssignment,Standard_Transient)
void StepBasic_DateAssignment::Init(
const Handle(StepBasic_Date)& aAssignedDate,
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_Date;
class StepBasic_DateRole;
class StepBasic_DateAssignment;
-DEFINE_STANDARD_HANDLE(StepBasic_DateAssignment, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_DateAssignment, Standard_Transient)
-class StepBasic_DateAssignment : public MMgt_TShared
+class StepBasic_DateAssignment : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_DateAssignment,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_DateAssignment,Standard_Transient)
protected:
#include <StepBasic_DateRole.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_DateRole,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_DateRole,Standard_Transient)
StepBasic_DateRole::StepBasic_DateRole () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_DateRole;
-DEFINE_STANDARD_HANDLE(StepBasic_DateRole, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_DateRole, Standard_Transient)
-class StepBasic_DateRole : public MMgt_TShared
+class StepBasic_DateRole : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_DateRole,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_DateRole,Standard_Transient)
protected:
#include <StepBasic_DateTimeRole.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_DateTimeRole,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_DateTimeRole,Standard_Transient)
StepBasic_DateTimeRole::StepBasic_DateTimeRole () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_DateTimeRole;
-DEFINE_STANDARD_HANDLE(StepBasic_DateTimeRole, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_DateTimeRole, Standard_Transient)
-class StepBasic_DateTimeRole : public MMgt_TShared
+class StepBasic_DateTimeRole : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_DateTimeRole,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_DateTimeRole,Standard_Transient)
protected:
#include <StepBasic_DerivedUnit.hxx>
#include <StepBasic_DerivedUnitElement.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_DerivedUnit,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_DerivedUnit,Standard_Transient)
StepBasic_DerivedUnit::StepBasic_DerivedUnit () { }
#include <Standard_Type.hxx>
#include <StepBasic_HArray1OfDerivedUnitElement.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
class StepBasic_DerivedUnitElement;
class StepBasic_DerivedUnit;
-DEFINE_STANDARD_HANDLE(StepBasic_DerivedUnit, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_DerivedUnit, Standard_Transient)
//! Added from StepBasic Rev2 to Rev4
-class StepBasic_DerivedUnit : public MMgt_TShared
+class StepBasic_DerivedUnit : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_DerivedUnit,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_DerivedUnit,Standard_Transient)
protected:
#include <StepBasic_DerivedUnitElement.hxx>
#include <StepBasic_NamedUnit.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_DerivedUnitElement,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_DerivedUnitElement,Standard_Transient)
StepBasic_DerivedUnitElement::StepBasic_DerivedUnitElement () { }
#include <Standard_Type.hxx>
#include <Standard_Real.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_NamedUnit;
class StepBasic_DerivedUnitElement;
-DEFINE_STANDARD_HANDLE(StepBasic_DerivedUnitElement, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_DerivedUnitElement, Standard_Transient)
//! Added from StepBasic Rev2 to Rev4
-class StepBasic_DerivedUnitElement : public MMgt_TShared
+class StepBasic_DerivedUnitElement : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_DerivedUnitElement,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_DerivedUnitElement,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <StepBasic_DimensionalExponents.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_DimensionalExponents,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_DimensionalExponents,Standard_Transient)
StepBasic_DimensionalExponents::StepBasic_DimensionalExponents () {}
#include <Standard_Type.hxx>
#include <Standard_Real.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_DimensionalExponents;
-DEFINE_STANDARD_HANDLE(StepBasic_DimensionalExponents, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_DimensionalExponents, Standard_Transient)
-class StepBasic_DimensionalExponents : public MMgt_TShared
+class StepBasic_DimensionalExponents : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_DimensionalExponents,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_DimensionalExponents,Standard_Transient)
protected:
#include <StepBasic_DocumentType.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_Document,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_Document,Standard_Transient)
//=======================================================================
//function : StepBasic_Document
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_DocumentType;
class StepBasic_Document;
-DEFINE_STANDARD_HANDLE(StepBasic_Document, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_Document, Standard_Transient)
//! Representation of STEP entity Document
-class StepBasic_Document : public MMgt_TShared
+class StepBasic_Document : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_Document,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_Document,Standard_Transient)
protected:
#include <StepBasic_ProductOrFormationOrDefinition.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_DocumentProductAssociation,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_DocumentProductAssociation,Standard_Transient)
//=======================================================================
//function : StepBasic_DocumentProductAssociation
#include <StepBasic_ProductOrFormationOrDefinition.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_Document;
class StepBasic_ProductOrFormationOrDefinition;
class StepBasic_DocumentProductAssociation;
-DEFINE_STANDARD_HANDLE(StepBasic_DocumentProductAssociation, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_DocumentProductAssociation, Standard_Transient)
//! Representation of STEP entity DocumentProductAssociation
-class StepBasic_DocumentProductAssociation : public MMgt_TShared
+class StepBasic_DocumentProductAssociation : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_DocumentProductAssociation,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_DocumentProductAssociation,Standard_Transient)
protected:
#include <StepBasic_DocumentReference.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_DocumentReference,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_DocumentReference,Standard_Transient)
void StepBasic_DocumentReference::Init0
(const Handle(StepBasic_Document)& aAssignedDocument,
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_Document;
class TCollection_HAsciiString;
class StepBasic_DocumentReference;
-DEFINE_STANDARD_HANDLE(StepBasic_DocumentReference, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_DocumentReference, Standard_Transient)
-class StepBasic_DocumentReference : public MMgt_TShared
+class StepBasic_DocumentReference : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_DocumentReference,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_DocumentReference,Standard_Transient)
protected:
#include <StepBasic_DocumentRelationship.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_DocumentRelationship,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_DocumentRelationship,Standard_Transient)
StepBasic_DocumentRelationship::StepBasic_DocumentRelationship () { }
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_Document;
class StepBasic_DocumentRelationship;
-DEFINE_STANDARD_HANDLE(StepBasic_DocumentRelationship, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_DocumentRelationship, Standard_Transient)
-class StepBasic_DocumentRelationship : public MMgt_TShared
+class StepBasic_DocumentRelationship : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_DocumentRelationship,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_DocumentRelationship,Standard_Transient)
protected:
#include <StepBasic_DocumentRepresentationType.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_DocumentRepresentationType,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_DocumentRepresentationType,Standard_Transient)
//=======================================================================
//function : StepBasic_DocumentRepresentationType
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_Document;
class StepBasic_DocumentRepresentationType;
-DEFINE_STANDARD_HANDLE(StepBasic_DocumentRepresentationType, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_DocumentRepresentationType, Standard_Transient)
//! Representation of STEP entity DocumentRepresentationType
-class StepBasic_DocumentRepresentationType : public MMgt_TShared
+class StepBasic_DocumentRepresentationType : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_DocumentRepresentationType,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_DocumentRepresentationType,Standard_Transient)
protected:
#include <StepBasic_DocumentType.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_DocumentType,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_DocumentType,Standard_Transient)
StepBasic_DocumentType::StepBasic_DocumentType () { }
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_DocumentType;
-DEFINE_STANDARD_HANDLE(StepBasic_DocumentType, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_DocumentType, Standard_Transient)
-class StepBasic_DocumentType : public MMgt_TShared
+class StepBasic_DocumentType : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_DocumentType,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_DocumentType,Standard_Transient)
protected:
#include <StepBasic_DocumentUsageConstraint.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_DocumentUsageConstraint,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_DocumentUsageConstraint,Standard_Transient)
StepBasic_DocumentUsageConstraint::StepBasic_DocumentUsageConstraint () { }
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_Document;
class TCollection_HAsciiString;
class StepBasic_DocumentUsageConstraint;
-DEFINE_STANDARD_HANDLE(StepBasic_DocumentUsageConstraint, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_DocumentUsageConstraint, Standard_Transient)
-class StepBasic_DocumentUsageConstraint : public MMgt_TShared
+class StepBasic_DocumentUsageConstraint : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_DocumentUsageConstraint,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_DocumentUsageConstraint,Standard_Transient)
protected:
#include <StepBasic_Effectivity.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_Effectivity,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_Effectivity,Standard_Transient)
StepBasic_Effectivity::StepBasic_Effectivity () { }
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_Effectivity;
-DEFINE_STANDARD_HANDLE(StepBasic_Effectivity, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_Effectivity, Standard_Transient)
-class StepBasic_Effectivity : public MMgt_TShared
+class StepBasic_Effectivity : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_Effectivity,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_Effectivity,Standard_Transient)
protected:
#include <StepBasic_Effectivity.hxx>
#include <StepBasic_EffectivityAssignment.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_EffectivityAssignment,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_EffectivityAssignment,Standard_Transient)
//=======================================================================
//function : StepBasic_EffectivityAssignment
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_Effectivity;
class StepBasic_EffectivityAssignment;
-DEFINE_STANDARD_HANDLE(StepBasic_EffectivityAssignment, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_EffectivityAssignment, Standard_Transient)
//! Representation of STEP entity EffectivityAssignment
-class StepBasic_EffectivityAssignment : public MMgt_TShared
+class StepBasic_EffectivityAssignment : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_EffectivityAssignment,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_EffectivityAssignment,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <StepBasic_EulerAngles.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_EulerAngles,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_EulerAngles,Standard_Transient)
//=======================================================================
//function : StepBasic_EulerAngles
#include <Standard_Type.hxx>
#include <TColStd_HArray1OfReal.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_EulerAngles;
-DEFINE_STANDARD_HANDLE(StepBasic_EulerAngles, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_EulerAngles, Standard_Transient)
//! Representation of STEP entity EulerAngles
-class StepBasic_EulerAngles : public MMgt_TShared
+class StepBasic_EulerAngles : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_EulerAngles,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_EulerAngles,Standard_Transient)
protected:
#include <StepBasic_ExternalSource.hxx>
#include <StepBasic_SourceItem.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ExternalSource,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ExternalSource,Standard_Transient)
//=======================================================================
//function : StepBasic_ExternalSource
#include <Standard_Type.hxx>
#include <StepBasic_SourceItem.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_SourceItem;
class StepBasic_ExternalSource;
-DEFINE_STANDARD_HANDLE(StepBasic_ExternalSource, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_ExternalSource, Standard_Transient)
//! Representation of STEP entity ExternalSource
-class StepBasic_ExternalSource : public MMgt_TShared
+class StepBasic_ExternalSource : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_ExternalSource,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_ExternalSource,Standard_Transient)
protected:
#include <StepBasic_ExternalSource.hxx>
#include <StepBasic_SourceItem.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ExternallyDefinedItem,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ExternallyDefinedItem,Standard_Transient)
//=======================================================================
//function : StepBasic_ExternallyDefinedItem
#include <Standard_Type.hxx>
#include <StepBasic_SourceItem.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_ExternalSource;
class StepBasic_SourceItem;
class StepBasic_ExternallyDefinedItem;
-DEFINE_STANDARD_HANDLE(StepBasic_ExternallyDefinedItem, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_ExternallyDefinedItem, Standard_Transient)
//! Representation of STEP entity ExternallyDefinedItem
-class StepBasic_ExternallyDefinedItem : public MMgt_TShared
+class StepBasic_ExternallyDefinedItem : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_ExternallyDefinedItem,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_ExternallyDefinedItem,Standard_Transient)
protected:
#include <StepBasic_GeneralProperty.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_GeneralProperty,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_GeneralProperty,Standard_Transient)
//=======================================================================
//function : StepBasic_GeneralProperty
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_GeneralProperty;
-DEFINE_STANDARD_HANDLE(StepBasic_GeneralProperty, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_GeneralProperty, Standard_Transient)
//! Representation of STEP entity GeneralProperty
-class StepBasic_GeneralProperty : public MMgt_TShared
+class StepBasic_GeneralProperty : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_GeneralProperty,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_GeneralProperty,Standard_Transient)
protected:
#include <StepBasic_Group.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_Group,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_Group,Standard_Transient)
//=======================================================================
//function : StepBasic_Group
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_Group;
-DEFINE_STANDARD_HANDLE(StepBasic_Group, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_Group, Standard_Transient)
//! Representation of STEP entity Group
-class StepBasic_Group : public MMgt_TShared
+class StepBasic_Group : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_Group,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_Group,Standard_Transient)
protected:
#include <StepBasic_Group.hxx>
#include <StepBasic_GroupAssignment.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_GroupAssignment,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_GroupAssignment,Standard_Transient)
//=======================================================================
//function : StepBasic_GroupAssignment
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_Group;
class StepBasic_GroupAssignment;
-DEFINE_STANDARD_HANDLE(StepBasic_GroupAssignment, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_GroupAssignment, Standard_Transient)
//! Representation of STEP entity GroupAssignment
-class StepBasic_GroupAssignment : public MMgt_TShared
+class StepBasic_GroupAssignment : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_GroupAssignment,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_GroupAssignment,Standard_Transient)
protected:
#include <StepBasic_GroupRelationship.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_GroupRelationship,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_GroupRelationship,Standard_Transient)
//=======================================================================
//function : StepBasic_GroupRelationship
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_Group;
class StepBasic_GroupRelationship;
-DEFINE_STANDARD_HANDLE(StepBasic_GroupRelationship, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_GroupRelationship, Standard_Transient)
//! Representation of STEP entity GroupRelationship
-class StepBasic_GroupRelationship : public MMgt_TShared
+class StepBasic_GroupRelationship : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_GroupRelationship,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_GroupRelationship,Standard_Transient)
protected:
#include <StepBasic_IdentificationRole.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_IdentificationAssignment,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_IdentificationAssignment,Standard_Transient)
//=======================================================================
//function : StepBasic_IdentificationAssignment
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_IdentificationRole;
class StepBasic_IdentificationAssignment;
-DEFINE_STANDARD_HANDLE(StepBasic_IdentificationAssignment, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_IdentificationAssignment, Standard_Transient)
//! Representation of STEP entity IdentificationAssignment
-class StepBasic_IdentificationAssignment : public MMgt_TShared
+class StepBasic_IdentificationAssignment : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_IdentificationAssignment,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_IdentificationAssignment,Standard_Transient)
protected:
#include <StepBasic_IdentificationRole.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_IdentificationRole,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_IdentificationRole,Standard_Transient)
//=======================================================================
//function : StepBasic_IdentificationRole
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_IdentificationRole;
-DEFINE_STANDARD_HANDLE(StepBasic_IdentificationRole, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_IdentificationRole, Standard_Transient)
//! Representation of STEP entity IdentificationRole
-class StepBasic_IdentificationRole : public MMgt_TShared
+class StepBasic_IdentificationRole : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_IdentificationRole,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_IdentificationRole,Standard_Transient)
protected:
#include <StepBasic_CoordinatedUniversalTimeOffset.hxx>
#include <StepBasic_LocalTime.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_LocalTime,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_LocalTime,Standard_Transient)
StepBasic_LocalTime::StepBasic_LocalTime () {}
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_CoordinatedUniversalTimeOffset;
class StepBasic_LocalTime;
-DEFINE_STANDARD_HANDLE(StepBasic_LocalTime, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_LocalTime, Standard_Transient)
-class StepBasic_LocalTime : public MMgt_TShared
+class StepBasic_LocalTime : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_LocalTime,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_LocalTime,Standard_Transient)
protected:
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepBasic_Unit.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_MeasureWithUnit,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_MeasureWithUnit,Standard_Transient)
//=======================================================================
//function : StepBasic_MeasureWithUnit
#include <Standard_Type.hxx>
#include <StepBasic_Unit.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Real.hxx>
class StepBasic_MeasureValueMember;
class StepBasic_Unit;
class StepBasic_MeasureWithUnit;
-DEFINE_STANDARD_HANDLE(StepBasic_MeasureWithUnit, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_MeasureWithUnit, Standard_Transient)
-class StepBasic_MeasureWithUnit : public MMgt_TShared
+class StepBasic_MeasureWithUnit : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_MeasureWithUnit,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_MeasureWithUnit,Standard_Transient)
protected:
#include <StepBasic_NameAssignment.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_NameAssignment,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_NameAssignment,Standard_Transient)
//=======================================================================
//function : StepBasic_NameAssignment
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_NameAssignment;
-DEFINE_STANDARD_HANDLE(StepBasic_NameAssignment, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_NameAssignment, Standard_Transient)
//! Representation of STEP entity NameAssignment
-class StepBasic_NameAssignment : public MMgt_TShared
+class StepBasic_NameAssignment : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_NameAssignment,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_NameAssignment,Standard_Transient)
protected:
#include <StepBasic_DimensionalExponents.hxx>
#include <StepBasic_NamedUnit.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_NamedUnit,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_NamedUnit,Standard_Transient)
StepBasic_NamedUnit::StepBasic_NamedUnit () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_DimensionalExponents;
class StepBasic_NamedUnit;
-DEFINE_STANDARD_HANDLE(StepBasic_NamedUnit, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_NamedUnit, Standard_Transient)
-class StepBasic_NamedUnit : public MMgt_TShared
+class StepBasic_NamedUnit : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_NamedUnit,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_NamedUnit,Standard_Transient)
protected:
#include <StepBasic_ObjectRole.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ObjectRole,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ObjectRole,Standard_Transient)
//=======================================================================
//function : StepBasic_ObjectRole
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_ObjectRole;
-DEFINE_STANDARD_HANDLE(StepBasic_ObjectRole, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_ObjectRole, Standard_Transient)
//! Representation of STEP entity ObjectRole
-class StepBasic_ObjectRole : public MMgt_TShared
+class StepBasic_ObjectRole : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_ObjectRole,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_ObjectRole,Standard_Transient)
protected:
#include <StepBasic_Organization.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_Organization,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_Organization,Standard_Transient)
StepBasic_Organization::StepBasic_Organization () {}
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_Organization;
-DEFINE_STANDARD_HANDLE(StepBasic_Organization, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_Organization, Standard_Transient)
-class StepBasic_Organization : public MMgt_TShared
+class StepBasic_Organization : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_Organization,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_Organization,Standard_Transient)
protected:
#include <StepBasic_OrganizationAssignment.hxx>
#include <StepBasic_OrganizationRole.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_OrganizationAssignment,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_OrganizationAssignment,Standard_Transient)
void StepBasic_OrganizationAssignment::Init(
const Handle(StepBasic_Organization)& aAssignedOrganization,
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_Organization;
class StepBasic_OrganizationRole;
class StepBasic_OrganizationAssignment;
-DEFINE_STANDARD_HANDLE(StepBasic_OrganizationAssignment, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_OrganizationAssignment, Standard_Transient)
-class StepBasic_OrganizationAssignment : public MMgt_TShared
+class StepBasic_OrganizationAssignment : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_OrganizationAssignment,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_OrganizationAssignment,Standard_Transient)
protected:
#include <StepBasic_OrganizationRole.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_OrganizationRole,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_OrganizationRole,Standard_Transient)
StepBasic_OrganizationRole::StepBasic_OrganizationRole () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_OrganizationRole;
-DEFINE_STANDARD_HANDLE(StepBasic_OrganizationRole, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_OrganizationRole, Standard_Transient)
-class StepBasic_OrganizationRole : public MMgt_TShared
+class StepBasic_OrganizationRole : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_OrganizationRole,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_OrganizationRole,Standard_Transient)
protected:
#include <StepBasic_Person.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_Person,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_Person,Standard_Transient)
StepBasic_Person::StepBasic_Person () {}
#include <Interface_HArray1OfHAsciiString.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
class TCollection_HAsciiString;
class StepBasic_Person;
-DEFINE_STANDARD_HANDLE(StepBasic_Person, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_Person, Standard_Transient)
-class StepBasic_Person : public MMgt_TShared
+class StepBasic_Person : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_Person,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_Person,Standard_Transient)
protected:
#include <StepBasic_Person.hxx>
#include <StepBasic_PersonAndOrganization.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_PersonAndOrganization,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_PersonAndOrganization,Standard_Transient)
StepBasic_PersonAndOrganization::StepBasic_PersonAndOrganization () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_Person;
class StepBasic_Organization;
class StepBasic_PersonAndOrganization;
-DEFINE_STANDARD_HANDLE(StepBasic_PersonAndOrganization, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_PersonAndOrganization, Standard_Transient)
-class StepBasic_PersonAndOrganization : public MMgt_TShared
+class StepBasic_PersonAndOrganization : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_PersonAndOrganization,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_PersonAndOrganization,Standard_Transient)
protected:
#include <StepBasic_PersonAndOrganizationAssignment.hxx>
#include <StepBasic_PersonAndOrganizationRole.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_PersonAndOrganizationAssignment,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_PersonAndOrganizationAssignment,Standard_Transient)
void StepBasic_PersonAndOrganizationAssignment::Init(
const Handle(StepBasic_PersonAndOrganization)& aAssignedPersonAndOrganization,
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_PersonAndOrganization;
class StepBasic_PersonAndOrganizationRole;
class StepBasic_PersonAndOrganizationAssignment;
-DEFINE_STANDARD_HANDLE(StepBasic_PersonAndOrganizationAssignment, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_PersonAndOrganizationAssignment, Standard_Transient)
-class StepBasic_PersonAndOrganizationAssignment : public MMgt_TShared
+class StepBasic_PersonAndOrganizationAssignment : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_PersonAndOrganizationAssignment,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_PersonAndOrganizationAssignment,Standard_Transient)
protected:
#include <StepBasic_PersonAndOrganizationRole.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_PersonAndOrganizationRole,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_PersonAndOrganizationRole,Standard_Transient)
StepBasic_PersonAndOrganizationRole::StepBasic_PersonAndOrganizationRole () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_PersonAndOrganizationRole;
-DEFINE_STANDARD_HANDLE(StepBasic_PersonAndOrganizationRole, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_PersonAndOrganizationRole, Standard_Transient)
-class StepBasic_PersonAndOrganizationRole : public MMgt_TShared
+class StepBasic_PersonAndOrganizationRole : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_PersonAndOrganizationRole,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_PersonAndOrganizationRole,Standard_Transient)
protected:
#include <StepBasic_ProductContext.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_Product,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_Product,Standard_Transient)
StepBasic_Product::StepBasic_Product () {}
#include <Standard_Type.hxx>
#include <StepBasic_HArray1OfProductContext.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
class TCollection_HAsciiString;
class StepBasic_ProductContext;
class StepBasic_Product;
-DEFINE_STANDARD_HANDLE(StepBasic_Product, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_Product, Standard_Transient)
-class StepBasic_Product : public MMgt_TShared
+class StepBasic_Product : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_Product,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_Product,Standard_Transient)
protected:
#include <StepBasic_ProductCategory.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ProductCategory,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ProductCategory,Standard_Transient)
StepBasic_ProductCategory::StepBasic_ProductCategory () {}
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_ProductCategory;
-DEFINE_STANDARD_HANDLE(StepBasic_ProductCategory, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_ProductCategory, Standard_Transient)
-class StepBasic_ProductCategory : public MMgt_TShared
+class StepBasic_ProductCategory : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_ProductCategory,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_ProductCategory,Standard_Transient)
protected:
#include <StepBasic_ProductCategoryRelationship.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ProductCategoryRelationship,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ProductCategoryRelationship,Standard_Transient)
//=======================================================================
//function : StepBasic_ProductCategoryRelationship
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_ProductCategory;
class StepBasic_ProductCategoryRelationship;
-DEFINE_STANDARD_HANDLE(StepBasic_ProductCategoryRelationship, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_ProductCategoryRelationship, Standard_Transient)
//! Representation of STEP entity ProductCategoryRelationship
-class StepBasic_ProductCategoryRelationship : public MMgt_TShared
+class StepBasic_ProductCategoryRelationship : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_ProductCategoryRelationship,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_ProductCategoryRelationship,Standard_Transient)
protected:
#include <StepBasic_ProductDefinitionFormation.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ProductDefinition,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ProductDefinition,Standard_Transient)
StepBasic_ProductDefinition::StepBasic_ProductDefinition () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_ProductDefinitionFormation;
class StepBasic_ProductDefinitionContext;
class StepBasic_ProductDefinition;
-DEFINE_STANDARD_HANDLE(StepBasic_ProductDefinition, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_ProductDefinition, Standard_Transient)
-class StepBasic_ProductDefinition : public MMgt_TShared
+class StepBasic_ProductDefinition : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_ProductDefinition,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_ProductDefinition,Standard_Transient)
protected:
#include <StepBasic_ProductDefinitionFormation.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ProductDefinitionFormation,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ProductDefinitionFormation,Standard_Transient)
StepBasic_ProductDefinitionFormation::StepBasic_ProductDefinitionFormation () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_Product;
class StepBasic_ProductDefinitionFormation;
-DEFINE_STANDARD_HANDLE(StepBasic_ProductDefinitionFormation, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_ProductDefinitionFormation, Standard_Transient)
-class StepBasic_ProductDefinitionFormation : public MMgt_TShared
+class StepBasic_ProductDefinitionFormation : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_ProductDefinitionFormation,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_ProductDefinitionFormation,Standard_Transient)
protected:
#include <StepBasic_ProductDefinitionFormationRelationship.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ProductDefinitionFormationRelationship,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ProductDefinitionFormationRelationship,Standard_Transient)
//=======================================================================
//function : StepBasic_ProductDefinitionFormationRelationship
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_ProductDefinitionFormation;
class StepBasic_ProductDefinitionFormationRelationship;
-DEFINE_STANDARD_HANDLE(StepBasic_ProductDefinitionFormationRelationship, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_ProductDefinitionFormationRelationship, Standard_Transient)
//! Representation of STEP entity ProductDefinitionFormationRelationship
-class StepBasic_ProductDefinitionFormationRelationship : public MMgt_TShared
+class StepBasic_ProductDefinitionFormationRelationship : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_ProductDefinitionFormationRelationship,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_ProductDefinitionFormationRelationship,Standard_Transient)
protected:
#include <StepBasic_ExternalSource.hxx>
#include <StepBasic_ProductDefinitionReference.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ProductDefinitionReference, MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ProductDefinitionReference, Standard_Transient)
//=======================================================================
//function : StepBasic_ProductDefinitionReference
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_ExternalSource;
class StepBasic_ProductDefinitionReference;
-DEFINE_STANDARD_HANDLE(StepBasic_ProductDefinitionReference, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_ProductDefinitionReference, Standard_Transient)
//! Representation of STEP entity Product_Definition_Reference
-class StepBasic_ProductDefinitionReference : public MMgt_TShared
+class StepBasic_ProductDefinitionReference : public Standard_Transient
{
public:
return hasIdOwningOrganizationName;
}
- DEFINE_STANDARD_RTTIEXT(StepBasic_ProductDefinitionReference, MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_ProductDefinitionReference, Standard_Transient)
private:
Handle(StepBasic_ExternalSource) mySource;
#include <StepBasic_ProductDefinitionRelationship.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ProductDefinitionRelationship,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ProductDefinitionRelationship,Standard_Transient)
//=======================================================================
//function : StepBasic_ProductDefinitionRelationship
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <StepBasic_ProductDefinitionOrReference.hxx>
class TCollection_HAsciiString;
class StepBasic_ProductDefinition;
class StepBasic_ProductDefinitionRelationship;
-DEFINE_STANDARD_HANDLE(StepBasic_ProductDefinitionRelationship, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_ProductDefinitionRelationship, Standard_Transient)
//! Representation of STEP entity ProductDefinitionRelationship
-class StepBasic_ProductDefinitionRelationship : public MMgt_TShared
+class StepBasic_ProductDefinitionRelationship : public Standard_Transient
{
public:
Standard_EXPORT void SetRelatedProductDefinition (const StepBasic_ProductDefinitionOrReference& RelatedProductDefinition);
- DEFINE_STANDARD_RTTIEXT(StepBasic_ProductDefinitionRelationship,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_ProductDefinitionRelationship,Standard_Transient)
protected:
#include <StepBasic_RoleAssociation.hxx>
#include <StepBasic_RoleSelect.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_RoleAssociation,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_RoleAssociation,Standard_Transient)
//=======================================================================
//function : StepBasic_RoleAssociation
#include <Standard_Type.hxx>
#include <StepBasic_RoleSelect.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_ObjectRole;
class StepBasic_RoleSelect;
class StepBasic_RoleAssociation;
-DEFINE_STANDARD_HANDLE(StepBasic_RoleAssociation, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_RoleAssociation, Standard_Transient)
//! Representation of STEP entity RoleAssociation
-class StepBasic_RoleAssociation : public MMgt_TShared
+class StepBasic_RoleAssociation : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_RoleAssociation,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_RoleAssociation,Standard_Transient)
protected:
#include <StepBasic_SecurityClassificationLevel.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_SecurityClassification,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_SecurityClassification,Standard_Transient)
StepBasic_SecurityClassification::StepBasic_SecurityClassification () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_SecurityClassificationLevel;
class StepBasic_SecurityClassification;
-DEFINE_STANDARD_HANDLE(StepBasic_SecurityClassification, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_SecurityClassification, Standard_Transient)
-class StepBasic_SecurityClassification : public MMgt_TShared
+class StepBasic_SecurityClassification : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_SecurityClassification,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_SecurityClassification,Standard_Transient)
protected:
#include <StepBasic_SecurityClassification.hxx>
#include <StepBasic_SecurityClassificationAssignment.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_SecurityClassificationAssignment,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_SecurityClassificationAssignment,Standard_Transient)
void StepBasic_SecurityClassificationAssignment::Init(
const Handle(StepBasic_SecurityClassification)& aAssignedSecurityClassification)
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_SecurityClassification;
class StepBasic_SecurityClassificationAssignment;
-DEFINE_STANDARD_HANDLE(StepBasic_SecurityClassificationAssignment, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_SecurityClassificationAssignment, Standard_Transient)
-class StepBasic_SecurityClassificationAssignment : public MMgt_TShared
+class StepBasic_SecurityClassificationAssignment : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_SecurityClassificationAssignment,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_SecurityClassificationAssignment,Standard_Transient)
protected:
#include <StepBasic_SecurityClassificationLevel.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_SecurityClassificationLevel,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_SecurityClassificationLevel,Standard_Transient)
StepBasic_SecurityClassificationLevel::StepBasic_SecurityClassificationLevel () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_SecurityClassificationLevel;
-DEFINE_STANDARD_HANDLE(StepBasic_SecurityClassificationLevel, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_SecurityClassificationLevel, Standard_Transient)
-class StepBasic_SecurityClassificationLevel : public MMgt_TShared
+class StepBasic_SecurityClassificationLevel : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_SecurityClassificationLevel,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_SecurityClassificationLevel,Standard_Transient)
protected:
#include <StepBasic_VersionedActionRequest.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepBasic_VersionedActionRequest,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepBasic_VersionedActionRequest,Standard_Transient)
//=======================================================================
//function : StepBasic_VersionedActionRequest
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_VersionedActionRequest;
-DEFINE_STANDARD_HANDLE(StepBasic_VersionedActionRequest, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepBasic_VersionedActionRequest, Standard_Transient)
//! Representation of STEP entity VersionedActionRequest
-class StepBasic_VersionedActionRequest : public MMgt_TShared
+class StepBasic_VersionedActionRequest : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepBasic_VersionedActionRequest,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepBasic_VersionedActionRequest,Standard_Transient)
protected:
#include <StepData_Field.hxx>
#include <StepData_Simple.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepData_Described,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepData_Described,Standard_Transient)
StepData_Described::StepData_Described (const Handle(StepData_EDescr)& descr)
: thedescr (descr) { }
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_CString.hxx>
class StepData_EDescr;
class StepData_Described;
-DEFINE_STANDARD_HANDLE(StepData_Described, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepData_Described, Standard_Transient)
//! General frame to describe entities with Description (Simple or
//! Complex)
-class StepData_Described : public MMgt_TShared
+class StepData_Described : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepData_Described,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepData_Described,Standard_Transient)
protected:
#include <StepData_Described.hxx>
#include <StepData_EDescr.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepData_EDescr,MMgt_TShared)
\ No newline at end of file
+IMPLEMENT_STANDARD_RTTIEXT(StepData_EDescr,Standard_Transient)
\ No newline at end of file
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_CString.hxx>
class StepData_Described;
class StepData_EDescr;
-DEFINE_STANDARD_HANDLE(StepData_EDescr, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepData_EDescr, Standard_Transient)
//! This class is intended to describe the authorized form for an
//! entity, either Simple or Plex
-class StepData_EDescr : public MMgt_TShared
+class StepData_EDescr : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepData_EDescr,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepData_EDescr,Standard_Transient)
protected:
#include <NCollection_DataMap.hxx>
#include <Standard_Transient.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepData_FreeFormEntity,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepData_FreeFormEntity,Standard_Transient)
void StepData_FreeFormEntity::SetStepType (const Standard_CString typenam)
{ thetype.Clear(); thetype.AssignCat (typenam); }
#include <TCollection_AsciiString.hxx>
#include <StepData_HArray1OfField.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
#include <Standard_Boolean.hxx>
#include <TColStd_HSequenceOfAsciiString.hxx>
class StepData_FreeFormEntity;
-DEFINE_STANDARD_HANDLE(StepData_FreeFormEntity, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepData_FreeFormEntity, Standard_Transient)
//! A Free Form Entity allows to record any kind of STEP
//! parameters, in any way of typing
//! It is implemented with an array of fields
//! A Complex entity can be defined, as a chain of FreeFormEntity
//! (see Next and As)
-class StepData_FreeFormEntity : public MMgt_TShared
+class StepData_FreeFormEntity : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepData_FreeFormEntity,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepData_FreeFormEntity,Standard_Transient)
protected:
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepData_GlobalNodeOfWriterLib;
class Standard_Transient;
class StepData_ReadWriteModule;
class StepData_NodeOfWriterLib;
-DEFINE_STANDARD_HANDLE(StepData_NodeOfWriterLib, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepData_NodeOfWriterLib, Standard_Transient)
-class StepData_NodeOfWriterLib : public MMgt_TShared
+class StepData_NodeOfWriterLib : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTI_INLINE(StepData_NodeOfWriterLib,MMgt_TShared)
+ DEFINE_STANDARD_RTTI_INLINE(StepData_NodeOfWriterLib,Standard_Transient)
protected:
#include <StepData_Field.hxx>
#include <StepData_PDescr.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepData_PDescr,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepData_PDescr,Standard_Transient)
#define KindInteger 1
#define KindBoolean 2
#include <StepData_EnumTool.hxx>
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
class StepData_EDescr;
class StepData_Field;
class StepData_PDescr;
-DEFINE_STANDARD_HANDLE(StepData_PDescr, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepData_PDescr, Standard_Transient)
//! This class is intended to describe the authorized form for a
//! parameter, as a type or a value for a field
//!
//! A PDescr firstly describes a type, which can be SELECT, i.e.
//! have several members
-class StepData_PDescr : public MMgt_TShared
+class StepData_PDescr : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepData_PDescr,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepData_PDescr,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <StepData_SelectMember.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepData_SelectMember,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepData_SelectMember,Standard_Transient)
// Definitions reprises de Field :
#define KindInteger 1
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_CString.hxx>
#include <Standard_Integer.hxx>
class StepData_SelectMember;
-DEFINE_STANDARD_HANDLE(StepData_SelectMember, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepData_SelectMember, Standard_Transient)
//! The general form for a Select Member. A Select Member can,
//! either define a value of a basic type (such as an integer)
//!
//! Remark : this class itself could be deferred, because at least
//! one of its virtual methods must be redefined to be usable
-class StepData_SelectMember : public MMgt_TShared
+class StepData_SelectMember : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepData_SelectMember,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepData_SelectMember,Standard_Transient)
protected:
#include <TCollection_AsciiString.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepData_UndefinedEntity,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepData_UndefinedEntity,Standard_Transient)
StepData_UndefinedEntity::StepData_UndefinedEntity ()
{ thecont = new Interface_UndefinedContent; thesub = Standard_False; }
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
#include <Standard_Integer.hxx>
class TCollection_HAsciiString;
class StepData_UndefinedEntity;
-DEFINE_STANDARD_HANDLE(StepData_UndefinedEntity, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepData_UndefinedEntity, Standard_Transient)
//! Undefined entity specific to Step Interface, in which StepType
//! is defined at each instance, or is a SubList of another one
//! Uses an UndefinedContent, that from Interface is suitable.
//! Also an Entity defined by STEP can be "Complex Type" (see
//! ANDOR clause in Express).
-class StepData_UndefinedEntity : public MMgt_TShared
+class StepData_UndefinedEntity : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepData_UndefinedEntity,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepData_UndefinedEntity,Standard_Transient)
protected:
#include <StepDimTol_Datum.hxx>
#include <StepDimTol_DatumReference.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepDimTol_DatumReference,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepDimTol_DatumReference,Standard_Transient)
//=======================================================================
//function : StepDimTol_DatumReference
#include <Standard_Type.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepDimTol_Datum;
class StepDimTol_DatumReference;
-DEFINE_STANDARD_HANDLE(StepDimTol_DatumReference, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepDimTol_DatumReference, Standard_Transient)
//! Representation of STEP entity DatumReference
-class StepDimTol_DatumReference : public MMgt_TShared
+class StepDimTol_DatumReference : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepDimTol_DatumReference,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepDimTol_DatumReference,Standard_Transient)
protected:
#include <StepDimTol_DatumReferenceModifierWithValue.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepDimTol_DatumReferenceModifierWithValue,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepDimTol_DatumReferenceModifierWithValue,Standard_Transient)
//=======================================================================
//function : StepDimTol_DatumReferenceModifierWithValue
#include <Standard_DefineHandle.hxx>
#include <Standard_Handle.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
#include <StepBasic_LengthMeasureWithUnit.hxx>
#include <StepDimTol_DatumReferenceModifierType.hxx>
class StepDimTol_DatumReferenceModifierWithValue;
-DEFINE_STANDARD_HANDLE(StepDimTol_DatumReferenceModifierWithValue, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepDimTol_DatumReferenceModifierWithValue, Standard_Transient)
//! Representation of STEP entity DatumReferenceModifierWithValue
-class StepDimTol_DatumReferenceModifierWithValue : public MMgt_TShared
+class StepDimTol_DatumReferenceModifierWithValue : public Standard_Transient
{
public:
myModifierValue = theModifierValue;
}
- DEFINE_STANDARD_RTTIEXT(StepDimTol_DatumReferenceModifierWithValue,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepDimTol_DatumReferenceModifierWithValue,Standard_Transient)
private:
StepDimTol_DatumReferenceModifierType myModifierType;
#include <StepRepr_ShapeAspect.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepDimTol_GeometricTolerance,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepDimTol_GeometricTolerance,Standard_Transient)
//=======================================================================
//function : StepDimTol_GeometricTolerance
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <StepDimTol_GeometricToleranceTarget.hxx>
class TCollection_HAsciiString;
class StepBasic_MeasureWithUnit;
class StepDimTol_GeometricTolerance;
-DEFINE_STANDARD_HANDLE(StepDimTol_GeometricTolerance, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepDimTol_GeometricTolerance, Standard_Transient)
//! Representation of STEP entity GeometricTolerance
-class StepDimTol_GeometricTolerance : public MMgt_TShared
+class StepDimTol_GeometricTolerance : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepDimTol_GeometricTolerance,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepDimTol_GeometricTolerance,Standard_Transient)
protected:
#include <StepDimTol_GeometricToleranceRelationship.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepDimTol_GeometricToleranceRelationship,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepDimTol_GeometricToleranceRelationship,Standard_Transient)
//=======================================================================
//function : StepDimTol_GeometricToleranceRelationship
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepDimTol_GeometricTolerance;
class StepDimTol_GeometricToleranceRelationship;
-DEFINE_STANDARD_HANDLE(StepDimTol_GeometricToleranceRelationship, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepDimTol_GeometricToleranceRelationship, Standard_Transient)
//! Representation of STEP entity GeometricToleranceRelationship
-class StepDimTol_GeometricToleranceRelationship : public MMgt_TShared
+class StepDimTol_GeometricToleranceRelationship : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepDimTol_GeometricToleranceRelationship,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepDimTol_GeometricToleranceRelationship,Standard_Transient)
protected:
#include <StepDimTol_RunoutZoneOrientation.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepDimTol_RunoutZoneOrientation,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepDimTol_RunoutZoneOrientation,Standard_Transient)
//=======================================================================
//function : StepDimTol_RunoutZoneOrientation
#include <StepDimTol_RunoutZoneOrientation.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <StepBasic_PlaneAngleMeasureWithUnit.hxx>
class StepDimTol_RunoutZoneOrientation;
-DEFINE_STANDARD_HANDLE(StepDimTol_RunoutZoneOrientation, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepDimTol_RunoutZoneOrientation, Standard_Transient)
//! Added for Dimensional Tolerances
-class StepDimTol_RunoutZoneOrientation : public MMgt_TShared
+class StepDimTol_RunoutZoneOrientation : public Standard_Transient
{
public:
myAngle = theAngle;
}
- DEFINE_STANDARD_RTTIEXT(StepDimTol_RunoutZoneOrientation,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepDimTol_RunoutZoneOrientation,Standard_Transient)
private:
Handle(StepBasic_PlaneAngleMeasureWithUnit) myAngle;
#include <StepRepr_HArray1OfShapeAspect.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepDimTol_ToleranceZoneDefinition,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepDimTol_ToleranceZoneDefinition,Standard_Transient)
//=======================================================================
//function : StepDimTol_ToleranceZoneDefinition
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
#include <StepRepr_HArray1OfShapeAspect.hxx>
#include <StepRepr_ShapeAspect.hxx>
class StepRepr_HArray1OfShapeAspect;
class StepDimTol_ToleranceZoneDefinition;
-DEFINE_STANDARD_HANDLE(StepDimTol_ToleranceZoneDefinition, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepDimTol_ToleranceZoneDefinition, Standard_Transient)
//! Representation of STEP entity ToleranceZoneDefinition
-class StepDimTol_ToleranceZoneDefinition : public MMgt_TShared
+class StepDimTol_ToleranceZoneDefinition : public Standard_Transient
{
public:
myZone = theZone;
}
- DEFINE_STANDARD_RTTIEXT(StepDimTol_ToleranceZoneDefinition,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepDimTol_ToleranceZoneDefinition,Standard_Transient)
private:
Handle(StepRepr_HArray1OfShapeAspect) myBoundaries;
#include <StepDimTol_ToleranceZoneForm.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepDimTol_ToleranceZoneForm,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepDimTol_ToleranceZoneForm,Standard_Transient)
//=======================================================================
//function : StepDimTol_ToleranceZoneForm
#include <StepDimTol_ToleranceZoneForm.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <TCollection_HAsciiString.hxx>
class TCollection_HAsciiString;
class StepDimTol_ToleranceZoneForm;
-DEFINE_STANDARD_HANDLE(StepDimTol_ToleranceZoneForm, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepDimTol_ToleranceZoneForm, Standard_Transient)
//! Added for Dimensional Tolerances
-class StepDimTol_ToleranceZoneForm : public MMgt_TShared
+class StepDimTol_ToleranceZoneForm : public Standard_Transient
{
public:
myName = theName;
}
- DEFINE_STANDARD_RTTIEXT(StepDimTol_ToleranceZoneForm,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepDimTol_ToleranceZoneForm,Standard_Transient)
private:
Handle(TCollection_HAsciiString) myName;
#include <StepRepr_RepresentationItem.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepElement_AnalysisItemWithinRepresentation,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepElement_AnalysisItemWithinRepresentation,Standard_Transient)
//=======================================================================
//function : StepElement_AnalysisItemWithinRepresentation
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepRepr_RepresentationItem;
class StepRepr_Representation;
class StepElement_AnalysisItemWithinRepresentation;
-DEFINE_STANDARD_HANDLE(StepElement_AnalysisItemWithinRepresentation, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepElement_AnalysisItemWithinRepresentation, Standard_Transient)
//! Representation of STEP entity AnalysisItemWithinRepresentation
-class StepElement_AnalysisItemWithinRepresentation : public MMgt_TShared
+class StepElement_AnalysisItemWithinRepresentation : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepElement_AnalysisItemWithinRepresentation,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepElement_AnalysisItemWithinRepresentation,Standard_Transient)
protected:
#include <StepElement_CurveElementEndReleasePacket.hxx>
#include <StepElement_CurveElementFreedom.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepElement_CurveElementEndReleasePacket,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepElement_CurveElementEndReleasePacket,Standard_Transient)
//=======================================================================
//function : StepElement_CurveElementEndReleasePacket
#include <StepElement_CurveElementFreedom.hxx>
#include <Standard_Real.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepElement_CurveElementFreedom;
class StepElement_CurveElementEndReleasePacket;
-DEFINE_STANDARD_HANDLE(StepElement_CurveElementEndReleasePacket, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepElement_CurveElementEndReleasePacket, Standard_Transient)
//! Representation of STEP entity CurveElementEndReleasePacket
-class StepElement_CurveElementEndReleasePacket : public MMgt_TShared
+class StepElement_CurveElementEndReleasePacket : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepElement_CurveElementEndReleasePacket,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepElement_CurveElementEndReleasePacket,Standard_Transient)
protected:
#include <StepElement_CurveElementSectionDefinition.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepElement_CurveElementSectionDefinition,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepElement_CurveElementSectionDefinition,Standard_Transient)
//=======================================================================
//function : StepElement_CurveElementSectionDefinition
#include <Standard_Type.hxx>
#include <Standard_Real.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepElement_CurveElementSectionDefinition;
-DEFINE_STANDARD_HANDLE(StepElement_CurveElementSectionDefinition, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepElement_CurveElementSectionDefinition, Standard_Transient)
//! Representation of STEP entity CurveElementSectionDefinition
-class StepElement_CurveElementSectionDefinition : public MMgt_TShared
+class StepElement_CurveElementSectionDefinition : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepElement_CurveElementSectionDefinition,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepElement_CurveElementSectionDefinition,Standard_Transient)
protected:
#include <StepElement_ElementDescriptor.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepElement_ElementDescriptor,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepElement_ElementDescriptor,Standard_Transient)
//=======================================================================
//function : StepElement_ElementDescriptor
#include <Standard_Type.hxx>
#include <StepElement_ElementOrder.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepElement_ElementDescriptor;
-DEFINE_STANDARD_HANDLE(StepElement_ElementDescriptor, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepElement_ElementDescriptor, Standard_Transient)
//! Representation of STEP entity ElementDescriptor
-class StepElement_ElementDescriptor : public MMgt_TShared
+class StepElement_ElementDescriptor : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepElement_ElementDescriptor,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepElement_ElementDescriptor,Standard_Transient)
protected:
#include <StepElement_ElementMaterial.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepElement_ElementMaterial,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepElement_ElementMaterial,Standard_Transient)
//=======================================================================
//function : StepElement_ElementMaterial
#include <Standard_Type.hxx>
#include <StepRepr_HArray1OfMaterialPropertyRepresentation.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepElement_ElementMaterial;
-DEFINE_STANDARD_HANDLE(StepElement_ElementMaterial, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepElement_ElementMaterial, Standard_Transient)
//! Representation of STEP entity ElementMaterial
-class StepElement_ElementMaterial : public MMgt_TShared
+class StepElement_ElementMaterial : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepElement_ElementMaterial,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepElement_ElementMaterial,Standard_Transient)
protected:
#include <StepElement_SurfaceSectionField.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepElement_SurfaceElementProperty,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepElement_SurfaceElementProperty,Standard_Transient)
//=======================================================================
//function : StepElement_SurfaceElementProperty
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepElement_SurfaceSectionField;
class StepElement_SurfaceElementProperty;
-DEFINE_STANDARD_HANDLE(StepElement_SurfaceElementProperty, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepElement_SurfaceElementProperty, Standard_Transient)
//! Representation of STEP entity SurfaceElementProperty
-class StepElement_SurfaceElementProperty : public MMgt_TShared
+class StepElement_SurfaceElementProperty : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepElement_SurfaceElementProperty,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepElement_SurfaceElementProperty,Standard_Transient)
protected:
#include <StepElement_MeasureOrUnspecifiedValue.hxx>
#include <StepElement_SurfaceSection.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepElement_SurfaceSection,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepElement_SurfaceSection,Standard_Transient)
//=======================================================================
//function : StepElement_SurfaceSection
#include <Standard_Type.hxx>
#include <StepElement_MeasureOrUnspecifiedValue.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepElement_MeasureOrUnspecifiedValue;
class StepElement_SurfaceSection;
-DEFINE_STANDARD_HANDLE(StepElement_SurfaceSection, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepElement_SurfaceSection, Standard_Transient)
//! Representation of STEP entity SurfaceSection
-class StepElement_SurfaceSection : public MMgt_TShared
+class StepElement_SurfaceSection : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepElement_SurfaceSection,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepElement_SurfaceSection,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <StepElement_SurfaceSectionField.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepElement_SurfaceSectionField,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepElement_SurfaceSectionField,Standard_Transient)
//=======================================================================
//function : StepElement_SurfaceSectionField
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepElement_SurfaceSectionField;
-DEFINE_STANDARD_HANDLE(StepElement_SurfaceSectionField, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepElement_SurfaceSectionField, Standard_Transient)
//! Representation of STEP entity SurfaceSectionField
-class StepElement_SurfaceSectionField : public MMgt_TShared
+class StepElement_SurfaceSectionField : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepElement_SurfaceSectionField,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepElement_SurfaceSectionField,Standard_Transient)
protected:
#include <StepFEA_Curve3dElementProperty.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepFEA_Curve3dElementProperty,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepFEA_Curve3dElementProperty,Standard_Transient)
//=======================================================================
//function : StepFEA_Curve3dElementProperty
#include <StepFEA_HArray1OfCurveElementInterval.hxx>
#include <StepFEA_HArray1OfCurveElementEndOffset.hxx>
#include <StepFEA_HArray1OfCurveElementEndRelease.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepFEA_Curve3dElementProperty;
-DEFINE_STANDARD_HANDLE(StepFEA_Curve3dElementProperty, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepFEA_Curve3dElementProperty, Standard_Transient)
//! Representation of STEP entity Curve3dElementProperty
-class StepFEA_Curve3dElementProperty : public MMgt_TShared
+class StepFEA_Curve3dElementProperty : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepFEA_Curve3dElementProperty,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepFEA_Curve3dElementProperty,Standard_Transient)
protected:
#include <StepFEA_CurveElementEndCoordinateSystem.hxx>
#include <StepFEA_CurveElementEndOffset.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepFEA_CurveElementEndOffset,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepFEA_CurveElementEndOffset,Standard_Transient)
//=======================================================================
//function : StepFEA_CurveElementEndOffset
#include <StepFEA_CurveElementEndCoordinateSystem.hxx>
#include <TColStd_HArray1OfReal.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepFEA_CurveElementEndCoordinateSystem;
class StepFEA_CurveElementEndOffset;
-DEFINE_STANDARD_HANDLE(StepFEA_CurveElementEndOffset, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepFEA_CurveElementEndOffset, Standard_Transient)
//! Representation of STEP entity CurveElementEndOffset
-class StepFEA_CurveElementEndOffset : public MMgt_TShared
+class StepFEA_CurveElementEndOffset : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepFEA_CurveElementEndOffset,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepFEA_CurveElementEndOffset,Standard_Transient)
protected:
#include <StepFEA_CurveElementEndCoordinateSystem.hxx>
#include <StepFEA_CurveElementEndRelease.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepFEA_CurveElementEndRelease,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepFEA_CurveElementEndRelease,Standard_Transient)
//=======================================================================
//function : StepFEA_CurveElementEndRelease
#include <StepFEA_CurveElementEndCoordinateSystem.hxx>
#include <StepElement_HArray1OfCurveElementEndReleasePacket.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepFEA_CurveElementEndCoordinateSystem;
class StepFEA_CurveElementEndRelease;
-DEFINE_STANDARD_HANDLE(StepFEA_CurveElementEndRelease, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepFEA_CurveElementEndRelease, Standard_Transient)
//! Representation of STEP entity CurveElementEndRelease
-class StepFEA_CurveElementEndRelease : public MMgt_TShared
+class StepFEA_CurveElementEndRelease : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepFEA_CurveElementEndRelease,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepFEA_CurveElementEndRelease,Standard_Transient)
protected:
#include <StepFEA_CurveElementInterval.hxx>
#include <StepFEA_CurveElementLocation.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepFEA_CurveElementInterval,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepFEA_CurveElementInterval,Standard_Transient)
//=======================================================================
//function : StepFEA_CurveElementInterval
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepFEA_CurveElementLocation;
class StepBasic_EulerAngles;
class StepFEA_CurveElementInterval;
-DEFINE_STANDARD_HANDLE(StepFEA_CurveElementInterval, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepFEA_CurveElementInterval, Standard_Transient)
//! Representation of STEP entity CurveElementInterval
-class StepFEA_CurveElementInterval : public MMgt_TShared
+class StepFEA_CurveElementInterval : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepFEA_CurveElementInterval,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepFEA_CurveElementInterval,Standard_Transient)
protected:
#include <StepFEA_CurveElementLocation.hxx>
#include <StepFEA_FeaParametricPoint.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepFEA_CurveElementLocation,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepFEA_CurveElementLocation,Standard_Transient)
//=======================================================================
//function : StepFEA_CurveElementLocation
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepFEA_FeaParametricPoint;
class StepFEA_CurveElementLocation;
-DEFINE_STANDARD_HANDLE(StepFEA_CurveElementLocation, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepFEA_CurveElementLocation, Standard_Transient)
//! Representation of STEP entity CurveElementLocation
-class StepFEA_CurveElementLocation : public MMgt_TShared
+class StepFEA_CurveElementLocation : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepFEA_CurveElementLocation,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepFEA_CurveElementLocation,Standard_Transient)
protected:
#include <StepFEA_ElementGeometricRelationship.hxx>
#include <StepFEA_ElementOrElementGroup.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepFEA_ElementGeometricRelationship,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepFEA_ElementGeometricRelationship,Standard_Transient)
//=======================================================================
//function : StepFEA_ElementGeometricRelationship
#include <StepFEA_ElementOrElementGroup.hxx>
#include <StepElement_ElementAspect.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepElement_AnalysisItemWithinRepresentation;
class StepFEA_ElementOrElementGroup;
class StepElement_ElementAspect;
class StepFEA_ElementGeometricRelationship;
-DEFINE_STANDARD_HANDLE(StepFEA_ElementGeometricRelationship, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepFEA_ElementGeometricRelationship, Standard_Transient)
//! Representation of STEP entity ElementGeometricRelationship
-class StepFEA_ElementGeometricRelationship : public MMgt_TShared
+class StepFEA_ElementGeometricRelationship : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepFEA_ElementGeometricRelationship,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepFEA_ElementGeometricRelationship,Standard_Transient)
protected:
#include <StepElement_CurveElementSectionDefinition.hxx>
#include <StepFEA_FeaCurveSectionGeometricRelationship.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepFEA_FeaCurveSectionGeometricRelationship,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepFEA_FeaCurveSectionGeometricRelationship,Standard_Transient)
//=======================================================================
//function : StepFEA_FeaCurveSectionGeometricRelationship
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepElement_CurveElementSectionDefinition;
class StepElement_AnalysisItemWithinRepresentation;
class StepFEA_FeaCurveSectionGeometricRelationship;
-DEFINE_STANDARD_HANDLE(StepFEA_FeaCurveSectionGeometricRelationship, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepFEA_FeaCurveSectionGeometricRelationship, Standard_Transient)
//! Representation of STEP entity FeaCurveSectionGeometricRelationship
-class StepFEA_FeaCurveSectionGeometricRelationship : public MMgt_TShared
+class StepFEA_FeaCurveSectionGeometricRelationship : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepFEA_FeaCurveSectionGeometricRelationship,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepFEA_FeaCurveSectionGeometricRelationship,Standard_Transient)
protected:
#include <StepElement_SurfaceSection.hxx>
#include <StepFEA_FeaSurfaceSectionGeometricRelationship.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepFEA_FeaSurfaceSectionGeometricRelationship,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepFEA_FeaSurfaceSectionGeometricRelationship,Standard_Transient)
//=======================================================================
//function : StepFEA_FeaSurfaceSectionGeometricRelationship
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepElement_SurfaceSection;
class StepElement_AnalysisItemWithinRepresentation;
class StepFEA_FeaSurfaceSectionGeometricRelationship;
-DEFINE_STANDARD_HANDLE(StepFEA_FeaSurfaceSectionGeometricRelationship, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepFEA_FeaSurfaceSectionGeometricRelationship, Standard_Transient)
//! Representation of STEP entity FeaSurfaceSectionGeometricRelationship
-class StepFEA_FeaSurfaceSectionGeometricRelationship : public MMgt_TShared
+class StepFEA_FeaSurfaceSectionGeometricRelationship : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepFEA_FeaSurfaceSectionGeometricRelationship,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepFEA_FeaSurfaceSectionGeometricRelationship,Standard_Transient)
protected:
#include <StepFEA_DegreeOfFreedom.hxx>
#include <StepFEA_FreedomAndCoefficient.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepFEA_FreedomAndCoefficient,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepFEA_FreedomAndCoefficient,Standard_Transient)
//=======================================================================
//function : StepFEA_FreedomAndCoefficient
#include <StepFEA_DegreeOfFreedom.hxx>
#include <StepElement_MeasureOrUnspecifiedValue.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepFEA_DegreeOfFreedom;
class StepElement_MeasureOrUnspecifiedValue;
class StepFEA_FreedomAndCoefficient;
-DEFINE_STANDARD_HANDLE(StepFEA_FreedomAndCoefficient, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepFEA_FreedomAndCoefficient, Standard_Transient)
//! Representation of STEP entity FreedomAndCoefficient
-class StepFEA_FreedomAndCoefficient : public MMgt_TShared
+class StepFEA_FreedomAndCoefficient : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepFEA_FreedomAndCoefficient,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepFEA_FreedomAndCoefficient,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <StepFEA_FreedomsList.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepFEA_FreedomsList,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepFEA_FreedomsList,Standard_Transient)
//=======================================================================
//function : StepFEA_FreedomsList
#include <Standard_Type.hxx>
#include <StepFEA_HArray1OfDegreeOfFreedom.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepFEA_FreedomsList;
-DEFINE_STANDARD_HANDLE(StepFEA_FreedomsList, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepFEA_FreedomsList, Standard_Transient)
//! Representation of STEP entity FreedomsList
-class StepFEA_FreedomsList : public MMgt_TShared
+class StepFEA_FreedomsList : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepFEA_FreedomsList,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepFEA_FreedomsList,Standard_Transient)
protected:
#include <StepGeom_CompositeCurveSegment.hxx>
#include <StepGeom_Curve.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepGeom_CompositeCurveSegment,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepGeom_CompositeCurveSegment,Standard_Transient)
StepGeom_CompositeCurveSegment::StepGeom_CompositeCurveSegment () {}
#include <StepGeom_TransitionCode.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepGeom_Curve;
class StepGeom_CompositeCurveSegment;
-DEFINE_STANDARD_HANDLE(StepGeom_CompositeCurveSegment, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepGeom_CompositeCurveSegment, Standard_Transient)
-class StepGeom_CompositeCurveSegment : public MMgt_TShared
+class StepGeom_CompositeCurveSegment : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepGeom_CompositeCurveSegment,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepGeom_CompositeCurveSegment,Standard_Transient)
protected:
#include <StepGeom_BoundedSurface.hxx>
#include <StepGeom_SurfacePatch.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepGeom_SurfacePatch,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepGeom_SurfacePatch,Standard_Transient)
StepGeom_SurfacePatch::StepGeom_SurfacePatch () {}
#include <StepGeom_TransitionCode.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepGeom_BoundedSurface;
class StepGeom_SurfacePatch;
-DEFINE_STANDARD_HANDLE(StepGeom_SurfacePatch, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepGeom_SurfacePatch, Standard_Transient)
-class StepGeom_SurfacePatch : public MMgt_TShared
+class StepGeom_SurfacePatch : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepGeom_SurfacePatch,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepGeom_SurfacePatch,Standard_Transient)
protected:
#include <StepRepr_AssemblyComponentUsageSubstitute.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepRepr_AssemblyComponentUsageSubstitute,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepRepr_AssemblyComponentUsageSubstitute,Standard_Transient)
StepRepr_AssemblyComponentUsageSubstitute::StepRepr_AssemblyComponentUsageSubstitute () { }
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepRepr_AssemblyComponentUsage;
class StepRepr_AssemblyComponentUsageSubstitute;
-DEFINE_STANDARD_HANDLE(StepRepr_AssemblyComponentUsageSubstitute, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepRepr_AssemblyComponentUsageSubstitute, Standard_Transient)
-class StepRepr_AssemblyComponentUsageSubstitute : public MMgt_TShared
+class StepRepr_AssemblyComponentUsageSubstitute : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepRepr_AssemblyComponentUsageSubstitute,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepRepr_AssemblyComponentUsageSubstitute,Standard_Transient)
protected:
#include <StepRepr_ConfigurationDesignItem.hxx>
#include <StepRepr_ConfigurationItem.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepRepr_ConfigurationDesign,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepRepr_ConfigurationDesign,Standard_Transient)
//=======================================================================
//function : StepRepr_ConfigurationDesign
#include <Standard_Type.hxx>
#include <StepRepr_ConfigurationDesignItem.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepRepr_ConfigurationItem;
class StepRepr_ConfigurationDesignItem;
class StepRepr_ConfigurationDesign;
-DEFINE_STANDARD_HANDLE(StepRepr_ConfigurationDesign, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepRepr_ConfigurationDesign, Standard_Transient)
//! Representation of STEP entity ConfigurationDesign
-class StepRepr_ConfigurationDesign : public MMgt_TShared
+class StepRepr_ConfigurationDesign : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepRepr_ConfigurationDesign,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepRepr_ConfigurationDesign,Standard_Transient)
protected:
#include <StepRepr_ProductConcept.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepRepr_ConfigurationItem,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepRepr_ConfigurationItem,Standard_Transient)
//=======================================================================
//function : StepRepr_ConfigurationItem
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepRepr_ProductConcept;
class StepRepr_ConfigurationItem;
-DEFINE_STANDARD_HANDLE(StepRepr_ConfigurationItem, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepRepr_ConfigurationItem, Standard_Transient)
//! Representation of STEP entity ConfigurationItem
-class StepRepr_ConfigurationItem : public MMgt_TShared
+class StepRepr_ConfigurationItem : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepRepr_ConfigurationItem,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepRepr_ConfigurationItem,Standard_Transient)
protected:
#include <StepRepr_DataEnvironment.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepRepr_DataEnvironment,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepRepr_DataEnvironment,Standard_Transient)
//=======================================================================
//function : StepRepr_DataEnvironment
#include <Standard_Type.hxx>
#include <StepRepr_HArray1OfPropertyDefinitionRepresentation.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepRepr_DataEnvironment;
-DEFINE_STANDARD_HANDLE(StepRepr_DataEnvironment, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepRepr_DataEnvironment, Standard_Transient)
//! Representation of STEP entity DataEnvironment
-class StepRepr_DataEnvironment : public MMgt_TShared
+class StepRepr_DataEnvironment : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepRepr_DataEnvironment,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepRepr_DataEnvironment,Standard_Transient)
protected:
#include <StepRepr_FunctionallyDefinedTransformation.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepRepr_FunctionallyDefinedTransformation,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepRepr_FunctionallyDefinedTransformation,Standard_Transient)
StepRepr_FunctionallyDefinedTransformation::StepRepr_FunctionallyDefinedTransformation () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepRepr_FunctionallyDefinedTransformation;
-DEFINE_STANDARD_HANDLE(StepRepr_FunctionallyDefinedTransformation, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepRepr_FunctionallyDefinedTransformation, Standard_Transient)
-class StepRepr_FunctionallyDefinedTransformation : public MMgt_TShared
+class StepRepr_FunctionallyDefinedTransformation : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepRepr_FunctionallyDefinedTransformation,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepRepr_FunctionallyDefinedTransformation,Standard_Transient)
protected:
#include <StepRepr_RepresentationItem.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepRepr_ItemDefinedTransformation,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepRepr_ItemDefinedTransformation,Standard_Transient)
StepRepr_ItemDefinedTransformation::StepRepr_ItemDefinedTransformation () { }
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepRepr_RepresentationItem;
class StepRepr_ItemDefinedTransformation;
-DEFINE_STANDARD_HANDLE(StepRepr_ItemDefinedTransformation, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepRepr_ItemDefinedTransformation, Standard_Transient)
//! Added from StepRepr Rev2 to Rev4
-class StepRepr_ItemDefinedTransformation : public MMgt_TShared
+class StepRepr_ItemDefinedTransformation : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepRepr_ItemDefinedTransformation,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepRepr_ItemDefinedTransformation,Standard_Transient)
protected:
#include <StepRepr_MaterialDesignation.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepRepr_MaterialDesignation,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepRepr_MaterialDesignation,Standard_Transient)
StepRepr_MaterialDesignation::StepRepr_MaterialDesignation () { }
#include <Standard_Type.hxx>
#include <StepRepr_CharacterizedDefinition.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepRepr_CharacterizedDefinition;
class StepRepr_MaterialDesignation;
-DEFINE_STANDARD_HANDLE(StepRepr_MaterialDesignation, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepRepr_MaterialDesignation, Standard_Transient)
-class StepRepr_MaterialDesignation : public MMgt_TShared
+class StepRepr_MaterialDesignation : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepRepr_MaterialDesignation,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepRepr_MaterialDesignation,Standard_Transient)
protected:
#include <StepRepr_ProductConcept.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepRepr_ProductConcept,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepRepr_ProductConcept,Standard_Transient)
//=======================================================================
//function : StepRepr_ProductConcept
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepBasic_ProductConceptContext;
class StepRepr_ProductConcept;
-DEFINE_STANDARD_HANDLE(StepRepr_ProductConcept, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepRepr_ProductConcept, Standard_Transient)
//! Representation of STEP entity ProductConcept
-class StepRepr_ProductConcept : public MMgt_TShared
+class StepRepr_ProductConcept : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepRepr_ProductConcept,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepRepr_ProductConcept,Standard_Transient)
protected:
#include <StepRepr_PropertyDefinition.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepRepr_PropertyDefinition,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepRepr_PropertyDefinition,Standard_Transient)
//=======================================================================
//function : StepRepr_PropertyDefinition
#include <StepRepr_CharacterizedDefinition.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepRepr_CharacterizedDefinition;
class StepRepr_PropertyDefinition;
-DEFINE_STANDARD_HANDLE(StepRepr_PropertyDefinition, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepRepr_PropertyDefinition, Standard_Transient)
//! Representation of STEP entity PropertyDefinition
-class StepRepr_PropertyDefinition : public MMgt_TShared
+class StepRepr_PropertyDefinition : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepRepr_PropertyDefinition,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepRepr_PropertyDefinition,Standard_Transient)
protected:
#include <StepRepr_PropertyDefinitionRelationship.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepRepr_PropertyDefinitionRelationship,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepRepr_PropertyDefinitionRelationship,Standard_Transient)
//=======================================================================
//function : StepRepr_PropertyDefinitionRelationship
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepRepr_PropertyDefinition;
class StepRepr_PropertyDefinitionRelationship;
-DEFINE_STANDARD_HANDLE(StepRepr_PropertyDefinitionRelationship, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepRepr_PropertyDefinitionRelationship, Standard_Transient)
//! Representation of STEP entity PropertyDefinitionRelationship
-class StepRepr_PropertyDefinitionRelationship : public MMgt_TShared
+class StepRepr_PropertyDefinitionRelationship : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepRepr_PropertyDefinitionRelationship,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepRepr_PropertyDefinitionRelationship,Standard_Transient)
protected:
#include <StepRepr_Representation.hxx>
#include <StepRepr_RepresentedDefinition.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepRepr_PropertyDefinitionRepresentation,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepRepr_PropertyDefinitionRepresentation,Standard_Transient)
//=======================================================================
//function : StepRepr_PropertyDefinitionRepresentation
#include <Standard_Type.hxx>
#include <StepRepr_RepresentedDefinition.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepRepr_Representation;
class StepRepr_RepresentedDefinition;
class StepRepr_PropertyDefinitionRepresentation;
-DEFINE_STANDARD_HANDLE(StepRepr_PropertyDefinitionRepresentation, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepRepr_PropertyDefinitionRepresentation, Standard_Transient)
//! Representation of STEP entity PropertyDefinitionRepresentation
-class StepRepr_PropertyDefinitionRepresentation : public MMgt_TShared
+class StepRepr_PropertyDefinitionRepresentation : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepRepr_PropertyDefinitionRepresentation,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepRepr_PropertyDefinitionRepresentation,Standard_Transient)
protected:
#include <StepRepr_RepresentationItem.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepRepr_Representation,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepRepr_Representation,Standard_Transient)
StepRepr_Representation::StepRepr_Representation () {}
#include <Standard_Type.hxx>
#include <StepRepr_HArray1OfRepresentationItem.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
class TCollection_HAsciiString;
class StepRepr_RepresentationContext;
class StepRepr_Representation;
-DEFINE_STANDARD_HANDLE(StepRepr_Representation, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepRepr_Representation, Standard_Transient)
-class StepRepr_Representation : public MMgt_TShared
+class StepRepr_Representation : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepRepr_Representation,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepRepr_Representation,Standard_Transient)
protected:
#include <StepRepr_RepresentationContext.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepRepr_RepresentationContext,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepRepr_RepresentationContext,Standard_Transient)
StepRepr_RepresentationContext::StepRepr_RepresentationContext () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepRepr_RepresentationContext;
-DEFINE_STANDARD_HANDLE(StepRepr_RepresentationContext, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepRepr_RepresentationContext, Standard_Transient)
-class StepRepr_RepresentationContext : public MMgt_TShared
+class StepRepr_RepresentationContext : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepRepr_RepresentationContext,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepRepr_RepresentationContext,Standard_Transient)
protected:
#include <StepRepr_RepresentationItem.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepRepr_RepresentationItem,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepRepr_RepresentationItem,Standard_Transient)
StepRepr_RepresentationItem::StepRepr_RepresentationItem () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepRepr_RepresentationItem;
-DEFINE_STANDARD_HANDLE(StepRepr_RepresentationItem, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepRepr_RepresentationItem, Standard_Transient)
-class StepRepr_RepresentationItem : public MMgt_TShared
+class StepRepr_RepresentationItem : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepRepr_RepresentationItem,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepRepr_RepresentationItem,Standard_Transient)
protected:
#include <StepRepr_RepresentationItem.hxx>
#include <StepRepr_RepresentationMap.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepRepr_RepresentationMap,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepRepr_RepresentationMap,Standard_Transient)
StepRepr_RepresentationMap::StepRepr_RepresentationMap () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepRepr_RepresentationItem;
class StepRepr_Representation;
class StepRepr_RepresentationMap;
-DEFINE_STANDARD_HANDLE(StepRepr_RepresentationMap, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepRepr_RepresentationMap, Standard_Transient)
-class StepRepr_RepresentationMap : public MMgt_TShared
+class StepRepr_RepresentationMap : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepRepr_RepresentationMap,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepRepr_RepresentationMap,Standard_Transient)
protected:
#include <StepRepr_RepresentationRelationship.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepRepr_RepresentationRelationship,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepRepr_RepresentationRelationship,Standard_Transient)
StepRepr_RepresentationRelationship::StepRepr_RepresentationRelationship () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepRepr_Representation;
class StepRepr_RepresentationRelationship;
-DEFINE_STANDARD_HANDLE(StepRepr_RepresentationRelationship, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepRepr_RepresentationRelationship, Standard_Transient)
-class StepRepr_RepresentationRelationship : public MMgt_TShared
+class StepRepr_RepresentationRelationship : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepRepr_RepresentationRelationship,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepRepr_RepresentationRelationship,Standard_Transient)
protected:
#include <StepRepr_ShapeAspect.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepRepr_ShapeAspect,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepRepr_ShapeAspect,Standard_Transient)
StepRepr_ShapeAspect::StepRepr_ShapeAspect () {}
#include <Standard_Type.hxx>
#include <StepData_Logical.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepRepr_ProductDefinitionShape;
class StepRepr_ShapeAspect;
-DEFINE_STANDARD_HANDLE(StepRepr_ShapeAspect, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepRepr_ShapeAspect, Standard_Transient)
-class StepRepr_ShapeAspect : public MMgt_TShared
+class StepRepr_ShapeAspect : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepRepr_ShapeAspect,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepRepr_ShapeAspect,Standard_Transient)
protected:
#include <StepRepr_ShapeAspectRelationship.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepRepr_ShapeAspectRelationship,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepRepr_ShapeAspectRelationship,Standard_Transient)
//=======================================================================
//function : StepRepr_ShapeAspectRelationship
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepRepr_ShapeAspect;
class StepRepr_ShapeAspectRelationship;
-DEFINE_STANDARD_HANDLE(StepRepr_ShapeAspectRelationship, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepRepr_ShapeAspectRelationship, Standard_Transient)
//! Representation of STEP entity ShapeAspectRelationship
-class StepRepr_ShapeAspectRelationship : public MMgt_TShared
+class StepRepr_ShapeAspectRelationship : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepRepr_ShapeAspectRelationship,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepRepr_ShapeAspectRelationship,Standard_Transient)
protected:
#include <StepGeom_CartesianPoint.hxx>
#include <StepShape_BoxDomain.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepShape_BoxDomain,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepShape_BoxDomain,Standard_Transient)
StepShape_BoxDomain::StepShape_BoxDomain () {}
#include <Standard_Type.hxx>
#include <Standard_Real.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepGeom_CartesianPoint;
class StepShape_BoxDomain;
-DEFINE_STANDARD_HANDLE(StepShape_BoxDomain, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepShape_BoxDomain, Standard_Transient)
-class StepShape_BoxDomain : public MMgt_TShared
+class StepShape_BoxDomain : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepShape_BoxDomain,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepShape_BoxDomain,Standard_Transient)
protected:
#include <StepRepr_ShapeRepresentationRelationship.hxx>
#include <StepShape_ContextDependentShapeRepresentation.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepShape_ContextDependentShapeRepresentation,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepShape_ContextDependentShapeRepresentation,Standard_Transient)
StepShape_ContextDependentShapeRepresentation::StepShape_ContextDependentShapeRepresentation () { }
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepRepr_ShapeRepresentationRelationship;
class StepRepr_ProductDefinitionShape;
class StepShape_ContextDependentShapeRepresentation;
-DEFINE_STANDARD_HANDLE(StepShape_ContextDependentShapeRepresentation, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepShape_ContextDependentShapeRepresentation, Standard_Transient)
-class StepShape_ContextDependentShapeRepresentation : public MMgt_TShared
+class StepShape_ContextDependentShapeRepresentation : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepShape_ContextDependentShapeRepresentation,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepShape_ContextDependentShapeRepresentation,Standard_Transient)
protected:
#include <StepShape_DimensionalCharacteristicRepresentation.hxx>
#include <StepShape_ShapeDimensionRepresentation.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepShape_DimensionalCharacteristicRepresentation,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepShape_DimensionalCharacteristicRepresentation,Standard_Transient)
//=======================================================================
//function : StepShape_DimensionalCharacteristicRepresentation
#include <Standard_Type.hxx>
#include <StepShape_DimensionalCharacteristic.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepShape_ShapeDimensionRepresentation;
class StepShape_DimensionalCharacteristic;
class StepShape_DimensionalCharacteristicRepresentation;
-DEFINE_STANDARD_HANDLE(StepShape_DimensionalCharacteristicRepresentation, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepShape_DimensionalCharacteristicRepresentation, Standard_Transient)
//! Representation of STEP entity DimensionalCharacteristicRepresentation
-class StepShape_DimensionalCharacteristicRepresentation : public MMgt_TShared
+class StepShape_DimensionalCharacteristicRepresentation : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepShape_DimensionalCharacteristicRepresentation,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepShape_DimensionalCharacteristicRepresentation,Standard_Transient)
protected:
#include <StepShape_DimensionalSize.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepShape_DimensionalSize,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepShape_DimensionalSize,Standard_Transient)
//=======================================================================
//function : StepShape_DimensionalSize
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepRepr_ShapeAspect;
class TCollection_HAsciiString;
class StepShape_DimensionalSize;
-DEFINE_STANDARD_HANDLE(StepShape_DimensionalSize, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepShape_DimensionalSize, Standard_Transient)
//! Representation of STEP entity DimensionalSize
-class StepShape_DimensionalSize : public MMgt_TShared
+class StepShape_DimensionalSize : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepShape_DimensionalSize,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepShape_DimensionalSize,Standard_Transient)
protected:
#include <StepShape_LimitsAndFits.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepShape_LimitsAndFits,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepShape_LimitsAndFits,Standard_Transient)
StepShape_LimitsAndFits::StepShape_LimitsAndFits () { }
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepShape_LimitsAndFits;
-DEFINE_STANDARD_HANDLE(StepShape_LimitsAndFits, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepShape_LimitsAndFits, Standard_Transient)
//! Added for Dimensional Tolerances
-class StepShape_LimitsAndFits : public MMgt_TShared
+class StepShape_LimitsAndFits : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepShape_LimitsAndFits,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepShape_LimitsAndFits,Standard_Transient)
protected:
#include <StepShape_ValueQualifier.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepShape_MeasureQualification,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepShape_MeasureQualification,Standard_Transient)
StepShape_MeasureQualification::StepShape_MeasureQualification () { }
#include <Standard_Type.hxx>
#include <StepShape_HArray1OfValueQualifier.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
class TCollection_HAsciiString;
class StepBasic_MeasureWithUnit;
class StepShape_MeasureQualification;
-DEFINE_STANDARD_HANDLE(StepShape_MeasureQualification, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepShape_MeasureQualification, Standard_Transient)
//! Added for Dimensional Tolerances
-class StepShape_MeasureQualification : public MMgt_TShared
+class StepShape_MeasureQualification : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepShape_MeasureQualification,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepShape_MeasureQualification,Standard_Transient)
protected:
#include <StepShape_PlusMinusTolerance.hxx>
#include <StepShape_ToleranceMethodDefinition.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepShape_PlusMinusTolerance,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepShape_PlusMinusTolerance,Standard_Transient)
StepShape_PlusMinusTolerance::StepShape_PlusMinusTolerance () { }
#include <StepShape_ToleranceMethodDefinition.hxx>
#include <StepShape_DimensionalCharacteristic.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepShape_ToleranceMethodDefinition;
class StepShape_DimensionalCharacteristic;
class StepShape_PlusMinusTolerance;
-DEFINE_STANDARD_HANDLE(StepShape_PlusMinusTolerance, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepShape_PlusMinusTolerance, Standard_Transient)
//! Added for Dimensional Tolerances
-class StepShape_PlusMinusTolerance : public MMgt_TShared
+class StepShape_PlusMinusTolerance : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepShape_PlusMinusTolerance,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepShape_PlusMinusTolerance,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <StepShape_PrecisionQualifier.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepShape_PrecisionQualifier,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepShape_PrecisionQualifier,Standard_Transient)
StepShape_PrecisionQualifier::StepShape_PrecisionQualifier () { }
#include <Standard_Type.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepShape_PrecisionQualifier;
-DEFINE_STANDARD_HANDLE(StepShape_PrecisionQualifier, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepShape_PrecisionQualifier, Standard_Transient)
//! Added for Dimensional Tolerances
-class StepShape_PrecisionQualifier : public MMgt_TShared
+class StepShape_PrecisionQualifier : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepShape_PrecisionQualifier,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepShape_PrecisionQualifier,Standard_Transient)
protected:
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepShape_ToleranceValue.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepShape_ToleranceValue,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepShape_ToleranceValue,Standard_Transient)
StepShape_ToleranceValue::StepShape_ToleranceValue () { }
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepBasic_MeasureWithUnit;
class StepShape_ToleranceValue;
-DEFINE_STANDARD_HANDLE(StepShape_ToleranceValue, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepShape_ToleranceValue, Standard_Transient)
//! Added for Dimensional Tolerances
-class StepShape_ToleranceValue : public MMgt_TShared
+class StepShape_ToleranceValue : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepShape_ToleranceValue,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepShape_ToleranceValue,Standard_Transient)
protected:
#include <StepShape_TypeQualifier.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepShape_TypeQualifier,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepShape_TypeQualifier,Standard_Transient)
StepShape_TypeQualifier::StepShape_TypeQualifier () { }
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepShape_TypeQualifier;
-DEFINE_STANDARD_HANDLE(StepShape_TypeQualifier, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepShape_TypeQualifier, Standard_Transient)
//! Added for Dimensional Tolerances
-class StepShape_TypeQualifier : public MMgt_TShared
+class StepShape_TypeQualifier : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepShape_TypeQualifier,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepShape_TypeQualifier,Standard_Transient)
protected:
#include <StepShape_ValueFormatTypeQualifier.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepShape_ValueFormatTypeQualifier,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepShape_ValueFormatTypeQualifier,Standard_Transient)
//=======================================================================
//function : StepShape_ValueFormatTypeQualifier
#include <StepShape_ValueFormatTypeQualifier.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <TCollection_HAsciiString.hxx>
class TCollection_HAsciiString;
class StepShape_ValueFormatTypeQualifier;
-DEFINE_STANDARD_HANDLE(StepShape_ValueFormatTypeQualifier, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepShape_ValueFormatTypeQualifier, Standard_Transient)
//! Added for Dimensional Tolerances
-class StepShape_ValueFormatTypeQualifier : public MMgt_TShared
+class StepShape_ValueFormatTypeQualifier : public Standard_Transient
{
public:
formatType = theFormatType;
}
- DEFINE_STANDARD_RTTIEXT(StepShape_ValueFormatTypeQualifier,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepShape_ValueFormatTypeQualifier,Standard_Transient)
private:
Handle(TCollection_HAsciiString) formatType;
//=======================================================================
void StepVisual_AnnotationFillAreaOccurrence::Init(const Handle(TCollection_HAsciiString)& theName,
const Handle(StepVisual_HArray1OfPresentationStyleAssignment)& theStyles,
- const Handle(MMgt_TShared)& theItem,
+ const Handle(Standard_Transient)& theItem,
const Handle(StepGeom_GeometricRepresentationItem)& theFillStyleTarget)
{
StepVisual_AnnotationOccurrence::Init(theName, theStyles, theItem);
//! Initialize all fields (own and inherited)
Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& theName,
const Handle(StepVisual_HArray1OfPresentationStyleAssignment)& theStyles,
- const Handle(MMgt_TShared)& theItem,
+ const Handle(Standard_Transient)& theItem,
const Handle(StepGeom_GeometricRepresentationItem)& theFillStyleTarget);
//! Returns field fill_style_target
//=======================================================================
void StepVisual_AnnotationPlane::Init (const Handle(TCollection_HAsciiString)& theName,
const Handle(StepVisual_HArray1OfPresentationStyleAssignment)& theStyles,
- const Handle(MMgt_TShared)& theItem,
+ const Handle(Standard_Transient)& theItem,
const Handle(StepVisual_HArray1OfAnnotationPlaneElement)& theElements)
{
StepVisual_AnnotationOccurrence::Init(theName, theStyles, theItem);
Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& theName,
const Handle(StepVisual_HArray1OfPresentationStyleAssignment)& theStyles,
- const Handle(MMgt_TShared)& theItem,
+ const Handle(Standard_Transient)& theItem,
const Handle(StepVisual_HArray1OfAnnotationPlaneElement)& theElements);
//! Returns field Elements
#include <StepVisual_PresentationArea.hxx>
#include <StepVisual_PresentationSet.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepVisual_AreaInSet,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_AreaInSet,Standard_Transient)
StepVisual_AreaInSet::StepVisual_AreaInSet () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepVisual_PresentationArea;
class StepVisual_PresentationSet;
class StepVisual_AreaInSet;
-DEFINE_STANDARD_HANDLE(StepVisual_AreaInSet, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepVisual_AreaInSet, Standard_Transient)
-class StepVisual_AreaInSet : public MMgt_TShared
+class StepVisual_AreaInSet : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepVisual_AreaInSet,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepVisual_AreaInSet,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <StepVisual_Colour.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepVisual_Colour,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_Colour,Standard_Transient)
StepVisual_Colour::StepVisual_Colour () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepVisual_Colour;
-DEFINE_STANDARD_HANDLE(StepVisual_Colour, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepVisual_Colour, Standard_Transient)
-class StepVisual_Colour : public MMgt_TShared
+class StepVisual_Colour : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepVisual_Colour,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepVisual_Colour,Standard_Transient)
protected:
void StepVisual_ContextDependentOverRidingStyledItem::Init(
const Handle(TCollection_HAsciiString)& aName,
const Handle(StepVisual_HArray1OfPresentationStyleAssignment)& aStyles,
- const Handle(MMgt_TShared)& aItem,
+ const Handle(Standard_Transient)& aItem,
const Handle(StepVisual_StyledItem)& aOverRiddenStyle,
const Handle(StepVisual_HArray1OfStyleContextSelect)& aStyleContext)
{
//! Returns a ContextDependentOverRidingStyledItem
Standard_EXPORT StepVisual_ContextDependentOverRidingStyledItem();
- Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& aName, const Handle(StepVisual_HArray1OfPresentationStyleAssignment)& aStyles, const Handle(MMgt_TShared)& aItem, const Handle(StepVisual_StyledItem)& aOverRiddenStyle, const Handle(StepVisual_HArray1OfStyleContextSelect)& aStyleContext);
+ Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& aName, const Handle(StepVisual_HArray1OfPresentationStyleAssignment)& aStyles, const Handle(Standard_Transient)& aItem, const Handle(StepVisual_StyledItem)& aOverRiddenStyle, const Handle(StepVisual_HArray1OfStyleContextSelect)& aStyleContext);
Standard_EXPORT void SetStyleContext (const Handle(StepVisual_HArray1OfStyleContextSelect)& aStyleContext);
#include <StepVisual_CurveStyleFontSelect.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepVisual_CurveStyle,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_CurveStyle,Standard_Transient)
StepVisual_CurveStyle::StepVisual_CurveStyle () {}
#include <StepVisual_CurveStyleFontSelect.hxx>
#include <StepBasic_SizeSelect.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepVisual_Colour;
class StepVisual_CurveStyleFontSelect;
class StepVisual_CurveStyle;
-DEFINE_STANDARD_HANDLE(StepVisual_CurveStyle, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepVisual_CurveStyle, Standard_Transient)
-class StepVisual_CurveStyle : public MMgt_TShared
+class StepVisual_CurveStyle : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepVisual_CurveStyle,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepVisual_CurveStyle,Standard_Transient)
protected:
#include <StepVisual_CurveStyleFontPattern.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepVisual_CurveStyleFont,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_CurveStyleFont,Standard_Transient)
StepVisual_CurveStyleFont::StepVisual_CurveStyleFont () {}
#include <Standard_Type.hxx>
#include <StepVisual_HArray1OfCurveStyleFontPattern.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
class TCollection_HAsciiString;
class StepVisual_CurveStyleFontPattern;
class StepVisual_CurveStyleFont;
-DEFINE_STANDARD_HANDLE(StepVisual_CurveStyleFont, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepVisual_CurveStyleFont, Standard_Transient)
-class StepVisual_CurveStyleFont : public MMgt_TShared
+class StepVisual_CurveStyleFont : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepVisual_CurveStyleFont,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepVisual_CurveStyleFont,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <StepVisual_CurveStyleFontPattern.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepVisual_CurveStyleFontPattern,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_CurveStyleFontPattern,Standard_Transient)
StepVisual_CurveStyleFontPattern::StepVisual_CurveStyleFontPattern () {}
#include <Standard_Type.hxx>
#include <Standard_Real.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepVisual_CurveStyleFontPattern;
-DEFINE_STANDARD_HANDLE(StepVisual_CurveStyleFontPattern, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepVisual_CurveStyleFontPattern, Standard_Transient)
-class StepVisual_CurveStyleFontPattern : public MMgt_TShared
+class StepVisual_CurveStyleFontPattern : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepVisual_CurveStyleFontPattern,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepVisual_CurveStyleFontPattern,Standard_Transient)
protected:
#include <StepVisual_FillStyleSelect.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepVisual_FillAreaStyle,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_FillAreaStyle,Standard_Transient)
StepVisual_FillAreaStyle::StepVisual_FillAreaStyle () {}
#include <Standard_Type.hxx>
#include <StepVisual_HArray1OfFillStyleSelect.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
class TCollection_HAsciiString;
class StepVisual_FillStyleSelect;
class StepVisual_FillAreaStyle;
-DEFINE_STANDARD_HANDLE(StepVisual_FillAreaStyle, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepVisual_FillAreaStyle, Standard_Transient)
-class StepVisual_FillAreaStyle : public MMgt_TShared
+class StepVisual_FillAreaStyle : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepVisual_FillAreaStyle,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepVisual_FillAreaStyle,Standard_Transient)
protected:
#include <StepVisual_FillAreaStyleColour.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepVisual_FillAreaStyleColour,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_FillAreaStyleColour,Standard_Transient)
StepVisual_FillAreaStyleColour::StepVisual_FillAreaStyleColour () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepVisual_Colour;
class StepVisual_FillAreaStyleColour;
-DEFINE_STANDARD_HANDLE(StepVisual_FillAreaStyleColour, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepVisual_FillAreaStyleColour, Standard_Transient)
-class StepVisual_FillAreaStyleColour : public MMgt_TShared
+class StepVisual_FillAreaStyleColour : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepVisual_FillAreaStyleColour,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepVisual_FillAreaStyleColour,Standard_Transient)
protected:
#include <StepVisual_Invisibility.hxx>
#include <StepVisual_InvisibleItem.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepVisual_Invisibility,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_Invisibility,Standard_Transient)
StepVisual_Invisibility::StepVisual_Invisibility () {}
#include <Standard_Type.hxx>
#include <StepVisual_HArray1OfInvisibleItem.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
class StepVisual_InvisibleItem;
class StepVisual_Invisibility;
-DEFINE_STANDARD_HANDLE(StepVisual_Invisibility, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepVisual_Invisibility, Standard_Transient)
-class StepVisual_Invisibility : public MMgt_TShared
+class StepVisual_Invisibility : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepVisual_Invisibility,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepVisual_Invisibility,Standard_Transient)
protected:
void StepVisual_OverRidingStyledItem::Init(
const Handle(TCollection_HAsciiString)& aName,
const Handle(StepVisual_HArray1OfPresentationStyleAssignment)& aStyles,
- const Handle(MMgt_TShared)& aItem,
+ const Handle(Standard_Transient)& aItem,
const Handle(StepVisual_StyledItem)& aOverRiddenStyle)
{
// --- classe own fields ---
//! Returns a OverRidingStyledItem
Standard_EXPORT StepVisual_OverRidingStyledItem();
- Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& aName, const Handle(StepVisual_HArray1OfPresentationStyleAssignment)& aStyles, const Handle(MMgt_TShared)& aItem, const Handle(StepVisual_StyledItem)& aOverRiddenStyle);
+ Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& aName, const Handle(StepVisual_HArray1OfPresentationStyleAssignment)& aStyles, const Handle(Standard_Transient)& aItem, const Handle(StepVisual_StyledItem)& aOverRiddenStyle);
Standard_EXPORT void SetOverRiddenStyle (const Handle(StepVisual_StyledItem)& aOverRiddenStyle);
#include <StepVisual_PointStyle.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepVisual_PointStyle,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_PointStyle,Standard_Transient)
StepVisual_PointStyle::StepVisual_PointStyle () {}
#include <StepVisual_MarkerSelect.hxx>
#include <StepBasic_SizeSelect.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepVisual_Colour;
class StepVisual_MarkerSelect;
class StepVisual_PointStyle;
-DEFINE_STANDARD_HANDLE(StepVisual_PointStyle, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepVisual_PointStyle, Standard_Transient)
-class StepVisual_PointStyle : public MMgt_TShared
+class StepVisual_PointStyle : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepVisual_PointStyle,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepVisual_PointStyle,Standard_Transient)
protected:
#include <StepVisual_PreDefinedItem.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepVisual_PreDefinedItem,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_PreDefinedItem,Standard_Transient)
StepVisual_PreDefinedItem::StepVisual_PreDefinedItem () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepVisual_PreDefinedItem;
-DEFINE_STANDARD_HANDLE(StepVisual_PreDefinedItem, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepVisual_PreDefinedItem, Standard_Transient)
-class StepVisual_PreDefinedItem : public MMgt_TShared
+class StepVisual_PreDefinedItem : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepVisual_PreDefinedItem,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepVisual_PreDefinedItem,Standard_Transient)
protected:
#include <StepVisual_PresentationLayerAssignment.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepVisual_PresentationLayerAssignment,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_PresentationLayerAssignment,Standard_Transient)
StepVisual_PresentationLayerAssignment::StepVisual_PresentationLayerAssignment () {}
#include <Standard_Type.hxx>
#include <StepVisual_HArray1OfLayeredItem.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
class TCollection_HAsciiString;
class StepVisual_LayeredItem;
class StepVisual_PresentationLayerAssignment;
-DEFINE_STANDARD_HANDLE(StepVisual_PresentationLayerAssignment, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepVisual_PresentationLayerAssignment, Standard_Transient)
-class StepVisual_PresentationLayerAssignment : public MMgt_TShared
+class StepVisual_PresentationLayerAssignment : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepVisual_PresentationLayerAssignment,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepVisual_PresentationLayerAssignment,Standard_Transient)
protected:
#include <StepVisual_PresentationLayerUsage.hxx>
#include <StepVisual_PresentationRepresentation.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepVisual_PresentationLayerUsage,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_PresentationLayerUsage,Standard_Transient)
StepVisual_PresentationLayerUsage::StepVisual_PresentationLayerUsage () { }
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepVisual_PresentationLayerAssignment;
class StepVisual_PresentationRepresentation;
class StepVisual_PresentationLayerUsage;
-DEFINE_STANDARD_HANDLE(StepVisual_PresentationLayerUsage, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepVisual_PresentationLayerUsage, Standard_Transient)
//! Added from StepVisual Rev2 to Rev4
-class StepVisual_PresentationLayerUsage : public MMgt_TShared
+class StepVisual_PresentationLayerUsage : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepVisual_PresentationLayerUsage,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepVisual_PresentationLayerUsage,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <StepVisual_PresentationSet.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepVisual_PresentationSet,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_PresentationSet,Standard_Transient)
StepVisual_PresentationSet::StepVisual_PresentationSet () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepVisual_PresentationSet;
-DEFINE_STANDARD_HANDLE(StepVisual_PresentationSet, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepVisual_PresentationSet, Standard_Transient)
-class StepVisual_PresentationSet : public MMgt_TShared
+class StepVisual_PresentationSet : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepVisual_PresentationSet,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepVisual_PresentationSet,Standard_Transient)
protected:
#include <StepVisual_PresentationSize.hxx>
#include <StepVisual_PresentationSizeAssignmentSelect.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepVisual_PresentationSize,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_PresentationSize,Standard_Transient)
StepVisual_PresentationSize::StepVisual_PresentationSize () {}
#include <Standard_Type.hxx>
#include <StepVisual_PresentationSizeAssignmentSelect.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepVisual_PlanarBox;
class StepVisual_PresentationSizeAssignmentSelect;
class StepVisual_PresentationSize;
-DEFINE_STANDARD_HANDLE(StepVisual_PresentationSize, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepVisual_PresentationSize, Standard_Transient)
-class StepVisual_PresentationSize : public MMgt_TShared
+class StepVisual_PresentationSize : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepVisual_PresentationSize,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepVisual_PresentationSize,Standard_Transient)
protected:
#include <StepVisual_PresentationStyleAssignment.hxx>
#include <StepVisual_PresentationStyleSelect.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepVisual_PresentationStyleAssignment,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_PresentationStyleAssignment,Standard_Transient)
StepVisual_PresentationStyleAssignment::StepVisual_PresentationStyleAssignment () {}
#include <Standard_Type.hxx>
#include <StepVisual_HArray1OfPresentationStyleSelect.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
class StepVisual_PresentationStyleSelect;
class StepVisual_PresentationStyleAssignment;
-DEFINE_STANDARD_HANDLE(StepVisual_PresentationStyleAssignment, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepVisual_PresentationStyleAssignment, Standard_Transient)
-class StepVisual_PresentationStyleAssignment : public MMgt_TShared
+class StepVisual_PresentationStyleAssignment : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepVisual_PresentationStyleAssignment,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepVisual_PresentationStyleAssignment,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <StepVisual_PresentedItem.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepVisual_PresentedItem,MMgt_TShared)
\ No newline at end of file
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_PresentedItem,Standard_Transient)
\ No newline at end of file
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepVisual_PresentedItem;
-DEFINE_STANDARD_HANDLE(StepVisual_PresentedItem, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepVisual_PresentedItem, Standard_Transient)
-class StepVisual_PresentedItem : public MMgt_TShared
+class StepVisual_PresentedItem : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepVisual_PresentedItem,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepVisual_PresentedItem,Standard_Transient)
protected:
#include <StepVisual_PresentedItem.hxx>
#include <StepVisual_PresentedItemRepresentation.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepVisual_PresentedItemRepresentation,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_PresentedItemRepresentation,Standard_Transient)
StepVisual_PresentedItemRepresentation::StepVisual_PresentedItemRepresentation () { }
#include <Standard_Type.hxx>
#include <StepVisual_PresentationRepresentationSelect.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepVisual_PresentedItem;
class StepVisual_PresentationRepresentationSelect;
class StepVisual_PresentedItemRepresentation;
-DEFINE_STANDARD_HANDLE(StepVisual_PresentedItemRepresentation, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepVisual_PresentedItemRepresentation, Standard_Transient)
//! Added from StepVisual Rev2 to Rev4
-class StepVisual_PresentedItemRepresentation : public MMgt_TShared
+class StepVisual_PresentedItemRepresentation : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepVisual_PresentedItemRepresentation,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepVisual_PresentedItemRepresentation,Standard_Transient)
protected:
void StepVisual_StyledItem::Init(
const Handle(TCollection_HAsciiString)& aName,
const Handle(StepVisual_HArray1OfPresentationStyleAssignment)& aStyles,
- const Handle(MMgt_TShared)& aItem)
+ const Handle(Standard_Transient)& aItem)
{
// --- classe own fields ---
myStyles = aStyles;
void StepVisual_StyledItem::SetItem(const StepVisual_StyledItemTarget& theItem)
{
- myItem = Handle(MMgt_TShared)::DownCast(theItem.Value());
+ myItem = theItem.Value();
}
Handle(StepRepr_RepresentationItem) StepVisual_StyledItem::Item() const
//! Returns a StyledItem
Standard_EXPORT StepVisual_StyledItem();
- Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& aName, const Handle(StepVisual_HArray1OfPresentationStyleAssignment)& aStyles, const Handle(MMgt_TShared)& aItem);
+ Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& aName, const Handle(StepVisual_HArray1OfPresentationStyleAssignment)& aStyles, const Handle(Standard_Transient)& aItem);
Standard_EXPORT void SetStyles (const Handle(StepVisual_HArray1OfPresentationStyleAssignment)& aStyles);
Handle(StepVisual_HArray1OfPresentationStyleAssignment) myStyles;
// May be StepRepr_RepresentationItem for AP214(203) and StepVisual_StyledItemTarget for AP242
- Handle(MMgt_TShared) myItem;
+ Handle(Standard_Transient) myItem;
};
#include <StepVisual_SurfaceStyleElementSelect.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepVisual_SurfaceSideStyle,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_SurfaceSideStyle,Standard_Transient)
StepVisual_SurfaceSideStyle::StepVisual_SurfaceSideStyle () {}
#include <Standard_Type.hxx>
#include <StepVisual_HArray1OfSurfaceStyleElementSelect.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
class TCollection_HAsciiString;
class StepVisual_SurfaceStyleElementSelect;
class StepVisual_SurfaceSideStyle;
-DEFINE_STANDARD_HANDLE(StepVisual_SurfaceSideStyle, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepVisual_SurfaceSideStyle, Standard_Transient)
-class StepVisual_SurfaceSideStyle : public MMgt_TShared
+class StepVisual_SurfaceSideStyle : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepVisual_SurfaceSideStyle,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepVisual_SurfaceSideStyle,Standard_Transient)
protected:
#include <StepVisual_CurveStyle.hxx>
#include <StepVisual_SurfaceStyleBoundary.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepVisual_SurfaceStyleBoundary,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_SurfaceStyleBoundary,Standard_Transient)
StepVisual_SurfaceStyleBoundary::StepVisual_SurfaceStyleBoundary () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepVisual_CurveStyle;
class StepVisual_SurfaceStyleBoundary;
-DEFINE_STANDARD_HANDLE(StepVisual_SurfaceStyleBoundary, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepVisual_SurfaceStyleBoundary, Standard_Transient)
-class StepVisual_SurfaceStyleBoundary : public MMgt_TShared
+class StepVisual_SurfaceStyleBoundary : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepVisual_SurfaceStyleBoundary,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepVisual_SurfaceStyleBoundary,Standard_Transient)
protected:
#include <StepVisual_CurveStyle.hxx>
#include <StepVisual_SurfaceStyleControlGrid.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepVisual_SurfaceStyleControlGrid,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_SurfaceStyleControlGrid,Standard_Transient)
StepVisual_SurfaceStyleControlGrid::StepVisual_SurfaceStyleControlGrid () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepVisual_CurveStyle;
class StepVisual_SurfaceStyleControlGrid;
-DEFINE_STANDARD_HANDLE(StepVisual_SurfaceStyleControlGrid, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepVisual_SurfaceStyleControlGrid, Standard_Transient)
-class StepVisual_SurfaceStyleControlGrid : public MMgt_TShared
+class StepVisual_SurfaceStyleControlGrid : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepVisual_SurfaceStyleControlGrid,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepVisual_SurfaceStyleControlGrid,Standard_Transient)
protected:
#include <StepVisual_FillAreaStyle.hxx>
#include <StepVisual_SurfaceStyleFillArea.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepVisual_SurfaceStyleFillArea,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_SurfaceStyleFillArea,Standard_Transient)
StepVisual_SurfaceStyleFillArea::StepVisual_SurfaceStyleFillArea () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepVisual_FillAreaStyle;
class StepVisual_SurfaceStyleFillArea;
-DEFINE_STANDARD_HANDLE(StepVisual_SurfaceStyleFillArea, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepVisual_SurfaceStyleFillArea, Standard_Transient)
-class StepVisual_SurfaceStyleFillArea : public MMgt_TShared
+class StepVisual_SurfaceStyleFillArea : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepVisual_SurfaceStyleFillArea,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepVisual_SurfaceStyleFillArea,Standard_Transient)
protected:
#include <StepVisual_DirectionCountSelect.hxx>
#include <StepVisual_SurfaceStyleParameterLine.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepVisual_SurfaceStyleParameterLine,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_SurfaceStyleParameterLine,Standard_Transient)
StepVisual_SurfaceStyleParameterLine::StepVisual_SurfaceStyleParameterLine () {}
#include <Standard_Type.hxx>
#include <StepVisual_HArray1OfDirectionCountSelect.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
class StepVisual_CurveStyle;
class StepVisual_DirectionCountSelect;
class StepVisual_SurfaceStyleParameterLine;
-DEFINE_STANDARD_HANDLE(StepVisual_SurfaceStyleParameterLine, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepVisual_SurfaceStyleParameterLine, Standard_Transient)
-class StepVisual_SurfaceStyleParameterLine : public MMgt_TShared
+class StepVisual_SurfaceStyleParameterLine : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepVisual_SurfaceStyleParameterLine,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepVisual_SurfaceStyleParameterLine,Standard_Transient)
protected:
#include <StepVisual_CurveStyle.hxx>
#include <StepVisual_SurfaceStyleSegmentationCurve.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepVisual_SurfaceStyleSegmentationCurve,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_SurfaceStyleSegmentationCurve,Standard_Transient)
StepVisual_SurfaceStyleSegmentationCurve::StepVisual_SurfaceStyleSegmentationCurve () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepVisual_CurveStyle;
class StepVisual_SurfaceStyleSegmentationCurve;
-DEFINE_STANDARD_HANDLE(StepVisual_SurfaceStyleSegmentationCurve, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepVisual_SurfaceStyleSegmentationCurve, Standard_Transient)
-class StepVisual_SurfaceStyleSegmentationCurve : public MMgt_TShared
+class StepVisual_SurfaceStyleSegmentationCurve : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepVisual_SurfaceStyleSegmentationCurve,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepVisual_SurfaceStyleSegmentationCurve,Standard_Transient)
protected:
#include <StepVisual_CurveStyle.hxx>
#include <StepVisual_SurfaceStyleSilhouette.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepVisual_SurfaceStyleSilhouette,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_SurfaceStyleSilhouette,Standard_Transient)
StepVisual_SurfaceStyleSilhouette::StepVisual_SurfaceStyleSilhouette () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepVisual_CurveStyle;
class StepVisual_SurfaceStyleSilhouette;
-DEFINE_STANDARD_HANDLE(StepVisual_SurfaceStyleSilhouette, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepVisual_SurfaceStyleSilhouette, Standard_Transient)
-class StepVisual_SurfaceStyleSilhouette : public MMgt_TShared
+class StepVisual_SurfaceStyleSilhouette : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepVisual_SurfaceStyleSilhouette,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepVisual_SurfaceStyleSilhouette,Standard_Transient)
protected:
#include <StepVisual_SurfaceSideStyle.hxx>
#include <StepVisual_SurfaceStyleUsage.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepVisual_SurfaceStyleUsage,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_SurfaceStyleUsage,Standard_Transient)
StepVisual_SurfaceStyleUsage::StepVisual_SurfaceStyleUsage () {}
#include <Standard_Type.hxx>
#include <StepVisual_SurfaceSide.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepVisual_SurfaceSideStyle;
class StepVisual_SurfaceStyleUsage;
-DEFINE_STANDARD_HANDLE(StepVisual_SurfaceStyleUsage, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepVisual_SurfaceStyleUsage, Standard_Transient)
-class StepVisual_SurfaceStyleUsage : public MMgt_TShared
+class StepVisual_SurfaceStyleUsage : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepVisual_SurfaceStyleUsage,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepVisual_SurfaceStyleUsage,Standard_Transient)
protected:
#include <StepVisual_TextStyleForDefinedFont.hxx>
#include <TCollection_HAsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepVisual_TextStyle,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_TextStyle,Standard_Transient)
StepVisual_TextStyle::StepVisual_TextStyle () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_HAsciiString;
class StepVisual_TextStyleForDefinedFont;
class StepVisual_TextStyle;
-DEFINE_STANDARD_HANDLE(StepVisual_TextStyle, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepVisual_TextStyle, Standard_Transient)
-class StepVisual_TextStyle : public MMgt_TShared
+class StepVisual_TextStyle : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepVisual_TextStyle,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepVisual_TextStyle,Standard_Transient)
protected:
#include <StepVisual_Colour.hxx>
#include <StepVisual_TextStyleForDefinedFont.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepVisual_TextStyleForDefinedFont,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_TextStyleForDefinedFont,Standard_Transient)
StepVisual_TextStyleForDefinedFont::StepVisual_TextStyleForDefinedFont () {}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepVisual_Colour;
class StepVisual_TextStyleForDefinedFont;
-DEFINE_STANDARD_HANDLE(StepVisual_TextStyleForDefinedFont, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepVisual_TextStyleForDefinedFont, Standard_Transient)
-class StepVisual_TextStyleForDefinedFont : public MMgt_TShared
+class StepVisual_TextStyleForDefinedFont : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepVisual_TextStyleForDefinedFont,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepVisual_TextStyleForDefinedFont,Standard_Transient)
protected:
#include <StepVisual_PlanarBox.hxx>
#include <StepVisual_ViewVolume.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StepVisual_ViewVolume,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StepVisual_ViewVolume,Standard_Transient)
StepVisual_ViewVolume::StepVisual_ViewVolume () {}
#include <StepVisual_CentralOrParallel.hxx>
#include <Standard_Real.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class StepGeom_CartesianPoint;
class StepVisual_PlanarBox;
class StepVisual_ViewVolume;
-DEFINE_STANDARD_HANDLE(StepVisual_ViewVolume, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StepVisual_ViewVolume, Standard_Transient)
-class StepVisual_ViewVolume : public MMgt_TShared
+class StepVisual_ViewVolume : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StepVisual_ViewVolume,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StepVisual_ViewVolume,Standard_Transient)
protected:
#include <StlMesh_Mesh.hxx>
#include <StlMesh_MeshDomain.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StlMesh_Mesh,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StlMesh_Mesh,Standard_Transient)
//=======================================================================
//function : StlMesh_Mesh
#include <Standard_Integer.hxx>
#include <StlMesh_SequenceOfMeshDomain.hxx>
#include <gp_XYZ.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Real.hxx>
#include <Standard_Boolean.hxx>
#include <StlMesh_SequenceOfMeshTriangle.hxx>
class StlMesh_Mesh;
-DEFINE_STANDARD_HANDLE(StlMesh_Mesh, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StlMesh_Mesh, Standard_Transient)
//! Mesh definition. The mesh contains one or several
//! domains. Each mesh domain contains a set of
//! triangles. Each domain can have its own deflection
//! value.
-class StlMesh_Mesh : public MMgt_TShared
+class StlMesh_Mesh : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StlMesh_Mesh,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StlMesh_Mesh,Standard_Transient)
protected:
#include <StlMesh_MeshDomain.hxx>
#include <StlMesh_MeshTriangle.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StlMesh_MeshDomain,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StlMesh_MeshDomain,Standard_Transient)
//=======================================================================
//function : StlMesh_MeshDomain
#include <Standard_Integer.hxx>
#include <TColgp_SequenceOfXYZ.hxx>
#include <StlMesh_SequenceOfMeshTriangle.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
class Standard_NegativeValue;
class Standard_NullValue;
class StlMesh_MeshDomain;
-DEFINE_STANDARD_HANDLE(StlMesh_MeshDomain, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StlMesh_MeshDomain, Standard_Transient)
//! A mesh domain is a set of triangles defined with
//! three geometric vertices and a given orientation.
//! The mesh domain has its own deflection.
//! Internal class used to classify the triangles of each domain.
-class StlMesh_MeshDomain : public MMgt_TShared
+class StlMesh_MeshDomain : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StlMesh_MeshDomain,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StlMesh_MeshDomain,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <StlMesh_MeshTriangle.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(StlMesh_MeshTriangle,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(StlMesh_MeshTriangle,Standard_Transient)
//=======================================================================
//function : StlMesh_MeshTriangle
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class Standard_NegativeValue;
class StlMesh_MeshTriangle;
-DEFINE_STANDARD_HANDLE(StlMesh_MeshTriangle, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(StlMesh_MeshTriangle, Standard_Transient)
//! A mesh triangle is defined with
//! three geometric vertices and an orientation
-class StlMesh_MeshTriangle : public MMgt_TShared
+class StlMesh_MeshTriangle : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(StlMesh_MeshTriangle,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(StlMesh_MeshTriangle,Standard_Transient)
protected:
#include <Storage_CallBack.hxx>
#include <Storage_Schema.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Storage_CallBack,MMgt_TShared)
\ No newline at end of file
+IMPLEMENT_STANDARD_RTTIEXT(Storage_CallBack,Standard_Transient)
\ No newline at end of file
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class Standard_Persistent;
class Storage_Schema;
class Storage_BaseDriver;
class Storage_CallBack;
-DEFINE_STANDARD_HANDLE(Storage_CallBack, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Storage_CallBack, Standard_Transient)
-class Storage_CallBack : public MMgt_TShared
+class Storage_CallBack : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Storage_CallBack,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Storage_CallBack,Standard_Transient)
protected:
#include <TCollection_AsciiString.hxx>
#include <TCollection_ExtendedString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Storage_Data,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Storage_Data,Standard_Transient)
Storage_Data::Storage_Data()
{
#include <Storage_Error.hxx>
#include <TCollection_AsciiString.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TColStd_SequenceOfAsciiString.hxx>
#include <TColStd_SequenceOfExtendedString.hxx>
#include <Standard_Integer.hxx>
class Storage_Data;
-DEFINE_STANDARD_HANDLE(Storage_Data, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Storage_Data, Standard_Transient)
//! A picture memorizing the data stored in a
//! container (for example, in a file).
//! are not maintained by the storage/retrieval
//! mechanism: external references are not
//! supported by Storage_Schema algorithm
-class Storage_Data : public MMgt_TShared
+class Storage_Data : public Standard_Transient
{
public:
friend class Storage_Schema;
- DEFINE_STANDARD_RTTIEXT(Storage_Data,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Storage_Data,Standard_Transient)
Standard_EXPORT Handle(Storage_HeaderData) HeaderData() const;
#include <TCollection_AsciiString.hxx>
#include <TCollection_ExtendedString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Storage_HeaderData,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Storage_HeaderData,Standard_Transient)
Storage_HeaderData::Storage_HeaderData() : myNBObj(0), myErrorStatus(Storage_VSOk)
{
#include <TColStd_SequenceOfAsciiString.hxx>
#include <TColStd_SequenceOfExtendedString.hxx>
#include <Storage_Error.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class Storage_Schema;
class Storage_BaseDriver;
class TCollection_AsciiString;
class Storage_HeaderData;
-DEFINE_STANDARD_HANDLE(Storage_HeaderData, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Storage_HeaderData, Standard_Transient)
-class Storage_HeaderData : public MMgt_TShared
+class Storage_HeaderData : public Standard_Transient
{
public:
friend class Storage_Schema;
- DEFINE_STANDARD_RTTIEXT(Storage_HeaderData,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Storage_HeaderData,Standard_Transient)
public:
#include <Storage_InternalData.hxx>
#include <Storage_Schema.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Storage_InternalData,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Storage_InternalData,Standard_Transient)
Storage_InternalData::Storage_InternalData() : myObjId(1), myTypeId(1)
{
#include <Standard_Integer.hxx>
#include <Storage_HPArray.hxx>
#include <Storage_MapOfCallBack.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class Storage_Schema;
class Storage_InternalData;
-DEFINE_STANDARD_HANDLE(Storage_InternalData, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Storage_InternalData, Standard_Transient)
-class Storage_InternalData : public MMgt_TShared
+class Storage_InternalData : public Standard_Transient
{
public:
friend class Storage_Schema;
- DEFINE_STANDARD_RTTIEXT(Storage_InternalData,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Storage_InternalData,Standard_Transient)
protected:
#include <Storage_Schema.hxx>
#include <TCollection_AsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Storage_Root,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Storage_Root,Standard_Transient)
Storage_Root::Storage_Root()
: myRef (0) {}
#include <TCollection_AsciiString.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class Standard_Persistent;
class Storage_Schema;
class TCollection_AsciiString;
class Storage_Root;
-DEFINE_STANDARD_HANDLE(Storage_Root, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Storage_Root, Standard_Transient)
//! A root object extracted from a Storage_Data object.
//! You do not create explicit roots: when inserting
//! data in a Storage_Data object, you just provide
//! the persistent object and optionally its name to the function AddRoot.
-class Storage_Root : public MMgt_TShared
+class Storage_Root : public Standard_Transient
{
public:
friend class Storage_Schema;
- DEFINE_STANDARD_RTTIEXT(Storage_Root,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Storage_Root,Standard_Transient)
protected:
#include <Storage_DataMapIteratorOfMapOfPers.hxx>
#include <TCollection_AsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Storage_RootData,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Storage_RootData,Standard_Transient)
Storage_RootData::Storage_RootData() : myErrorStatus(Storage_VSOk)
{
#include <Storage_MapOfPers.hxx>
#include <Storage_Error.hxx>
#include <TCollection_AsciiString.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
#include <Storage_HSeqOfRoot.hxx>
#include <Standard_Boolean.hxx>
class Storage_RootData;
-DEFINE_STANDARD_HANDLE(Storage_RootData, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Storage_RootData, Standard_Transient)
-class Storage_RootData : public MMgt_TShared
+class Storage_RootData : public Standard_Transient
{
public:
friend class Storage_Schema;
- DEFINE_STANDARD_RTTIEXT(Storage_RootData,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Storage_RootData,Standard_Transient)
protected:
#include <locale.h>
#include <stdio.h>
-IMPLEMENT_STANDARD_RTTIEXT(Storage_Schema,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Storage_Schema,Standard_Transient)
#define DATATYPE_MIGRATION
#include <Standard_Boolean.hxx>
#include <TCollection_AsciiString.hxx>
#include <Storage_HArrayOfSchema.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TColStd_SequenceOfAsciiString.hxx>
#include <TColStd_HSequenceOfAsciiString.hxx>
#include <Storage_SolveMode.hxx>
class Storage_Schema;
-DEFINE_STANDARD_HANDLE(Storage_Schema, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Storage_Schema, Standard_Transient)
//! Root class for basic storage/retrieval algorithms.
//! Storage_Schema algorithms are called basic
//! because they do not support external references
//! between containers.
-class Storage_Schema : public MMgt_TShared
+class Storage_Schema : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Storage_Schema,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Storage_Schema,Standard_Transient)
protected:
#include <Storage_StreamTypeMismatchError.hxx>
#include <TCollection_AsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Storage_TypeData,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Storage_TypeData,Standard_Transient)
Storage_TypeData::Storage_TypeData() : myErrorStatus(Storage_VSOk)
{
#include <Storage_PType.hxx>
#include <Storage_Error.hxx>
#include <TCollection_AsciiString.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
#include <TColStd_HSequenceOfAsciiString.hxx>
class Storage_TypeData;
-DEFINE_STANDARD_HANDLE(Storage_TypeData, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Storage_TypeData, Standard_Transient)
-class Storage_TypeData : public MMgt_TShared
+class Storage_TypeData : public Standard_Transient
{
public:
friend class Storage_Schema;
- DEFINE_STANDARD_RTTIEXT(Storage_TypeData,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Storage_TypeData,Standard_Transient)
protected:
#include <Storage_TypedCallBack.hxx>
#include <TCollection_AsciiString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Storage_TypedCallBack,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Storage_TypedCallBack,Standard_Transient)
Storage_TypedCallBack::Storage_TypedCallBack() : myIndex(0)
{
#include <TCollection_AsciiString.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class Storage_CallBack;
class TCollection_AsciiString;
class Storage_TypedCallBack;
-DEFINE_STANDARD_HANDLE(Storage_TypedCallBack, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Storage_TypedCallBack, Standard_Transient)
-class Storage_TypedCallBack : public MMgt_TShared
+class Storage_TypedCallBack : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Storage_TypedCallBack,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Storage_TypedCallBack,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TColStd_HPackedMapOfInteger.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TColStd_HPackedMapOfInteger,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TColStd_HPackedMapOfInteger,Standard_Transient)
//! Constructor of empty map
TColStd_HPackedMapOfInteger::TColStd_HPackedMapOfInteger (const Standard_Integer NbBuckets)
#include <Standard_Type.hxx>
#include <TColStd_PackedMapOfInteger.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
class TColStd_HPackedMapOfInteger;
-DEFINE_STANDARD_HANDLE(TColStd_HPackedMapOfInteger, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TColStd_HPackedMapOfInteger, Standard_Transient)
//! Extension of TColStd_PackedMapOfInteger class to be manipulated by handle.
-class TColStd_HPackedMapOfInteger : public MMgt_TShared
+class TColStd_HPackedMapOfInteger : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TColStd_HPackedMapOfInteger,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TColStd_HPackedMapOfInteger,Standard_Transient)
protected:
#include <TCollection_HAsciiString.hxx>
#include <TCollection_HExtendedString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TCollection_HAsciiString,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TCollection_HAsciiString,Standard_Transient)
// ----------------------------------------------------------------------------
// Create
#include <Standard_Type.hxx>
#include <TCollection_AsciiString.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
#include <Standard_Character.hxx>
#include <Standard_Integer.hxx>
class TCollection_HAsciiString;
-DEFINE_STANDARD_HANDLE(TCollection_HAsciiString, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TCollection_HAsciiString, Standard_Transient)
//! A variable-length sequence of ASCII characters
//! (normal 8-bit character type). It provides editing
//! - HAsciiString strings may be shared by several objects.
//! - You may use an AsciiString object to get the actual string.
//! Note: HAsciiString objects use an AsciiString string as a field.
-class TCollection_HAsciiString : public MMgt_TShared
+class TCollection_HAsciiString : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TCollection_HAsciiString,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TCollection_HAsciiString,Standard_Transient)
protected:
#include <TCollection_HAsciiString.hxx>
#include <TCollection_HExtendedString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TCollection_HExtendedString,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TCollection_HExtendedString,Standard_Transient)
// ----------------------------------------------------------------------------
// Create
#include <Standard_Type.hxx>
#include <TCollection_ExtendedString.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
#include <Standard_ExtString.hxx>
#include <Standard_ExtCharacter.hxx>
class TCollection_HExtendedString;
-DEFINE_STANDARD_HANDLE(TCollection_HExtendedString, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TCollection_HExtendedString, Standard_Transient)
//! A variable-length sequence of "extended"
//! (UNICODE) characters (16-bit character
//! - You may use an ExtendedString object to get the actual string.
//! Note: HExtendedString objects use an
//! ExtendedString string as a field.
-class TCollection_HExtendedString : public MMgt_TShared
+class TCollection_HExtendedString : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TCollection_HExtendedString,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TCollection_HExtendedString,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TCollection_MapNode.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TCollection_MapNode,MMgt_TShared)
\ No newline at end of file
+IMPLEMENT_STANDARD_RTTIEXT(TCollection_MapNode,Standard_Transient)
\ No newline at end of file
#include <Standard_Type.hxx>
#include <TCollection_MapNodePtr.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_MapNode;
-DEFINE_STANDARD_HANDLE(TCollection_MapNode, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TCollection_MapNode, Standard_Transient)
//! Basic class root of all the Maps.
-class TCollection_MapNode : public MMgt_TShared
+class TCollection_MapNode : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TCollection_MapNode,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TCollection_MapNode,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TCollection_SeqNode.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TCollection_SeqNode,MMgt_TShared)
\ No newline at end of file
+IMPLEMENT_STANDARD_RTTIEXT(TCollection_SeqNode,Standard_Transient)
\ No newline at end of file
#include <Standard_Type.hxx>
#include <TCollection_SeqNodePtr.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TCollection_SeqNode;
-DEFINE_STANDARD_HANDLE(TCollection_SeqNode, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TCollection_SeqNode, Standard_Transient)
-class TCollection_SeqNode : public MMgt_TShared
+class TCollection_SeqNode : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TCollection_SeqNode,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TCollection_SeqNode,Standard_Transient)
protected:
#include <TDF_RelocationTable.hxx>
#include <TDF_Tool.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TDF_Attribute,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TDF_Attribute,Standard_Transient)
#undef TDF_DATA_COMMIT_OPTIMIZED
#include <TDF_LabelNodePtr.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_OStream.hxx>
#include <TDF_AttributeIndexedMap.hxx>
class TDF_Attribute;
-DEFINE_STANDARD_HANDLE(TDF_Attribute, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TDF_Attribute, Standard_Transient)
//! A class each application has to implement. It is
//! used to contain the application data.
//! attribute values states. These methods must be
//! implemented by end use inheriting classes, to
//! profit from the delta services.
-class TDF_Attribute : public MMgt_TShared
+class TDF_Attribute : public Standard_Transient
{
public:
friend class TDF_DeltaOnForget;
- DEFINE_STANDARD_RTTIEXT(TDF_Attribute,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TDF_Attribute,Standard_Transient)
protected:
#include <TDF_Label.hxx>
#include <TDF_Tool.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TDF_AttributeDelta,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TDF_AttributeDelta,Standard_Transient)
//=======================================================================
//function : TDF_AttributeDelta
#include <Standard_Type.hxx>
#include <TDF_Label.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_OStream.hxx>
class TDF_Attribute;
class TDF_Label;
class TDF_AttributeDelta;
-DEFINE_STANDARD_HANDLE(TDF_AttributeDelta, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TDF_AttributeDelta, Standard_Transient)
//! This class discribes the services we need to
//! implement Delta and Undo/Redo services.
//! dead lock if found on the list, the
//! AttributeDeltas are forced to be applied in an
//! unpredictable order.
-class TDF_AttributeDelta : public MMgt_TShared
+class TDF_AttributeDelta : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TDF_AttributeDelta,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TDF_AttributeDelta,Standard_Transient)
protected:
#include <TDF_Tool.hxx>
#include <TDF_Transaction.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TDF_Data,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TDF_Data,Standard_Transient)
#undef DEB_DELTA_CREATION
#undef TDF_DATA_COMMIT_OPTIMIZED
#include <Standard_Boolean.hxx>
#include <TColStd_ListOfInteger.hxx>
#include <TDF_HAllocator.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TDF_Label.hxx>
#include <Standard_OStream.hxx>
class Standard_NoMoreObject;
class TDF_Data;
-DEFINE_STANDARD_HANDLE(TDF_Data, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TDF_Data, Standard_Transient)
//! This class is used to manipulate a complete
//! independant, self sufficient data structure and
//! (see LabelNodeAllocator() method)
//! for more efficient allocation of
//! objects in memory.
-class TDF_Data : public MMgt_TShared
+class TDF_Data : public Standard_Transient
{
public:
friend class TDF_LabelNode;
- DEFINE_STANDARD_RTTIEXT(TDF_Data,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TDF_Data,Standard_Transient)
protected:
#include <TDF_MapIteratorOfAttributeMap.hxx>
#include <TDF_MapIteratorOfLabelMap.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TDF_DataSet,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TDF_DataSet,Standard_Transient)
//=======================================================================
//function : TDF_DataSet
#include <TDF_LabelList.hxx>
#include <TDF_LabelMap.hxx>
#include <TDF_AttributeMap.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_OStream.hxx>
class TDF_Label;
class TDF_DataSet;
-DEFINE_STANDARD_HANDLE(TDF_DataSet, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TDF_DataSet, Standard_Transient)
//! This class is a set of TDF informations like
//! labels and attributes.
-class TDF_DataSet : public MMgt_TShared
+class TDF_DataSet : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TDF_DataSet,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TDF_DataSet,Standard_Transient)
protected:
#include <TDF_ListIteratorOfLabelList.hxx>
#include <TDF_MapIteratorOfLabelMap.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TDF_Delta,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TDF_Delta,Standard_Transient)
#ifdef OCCT_DEBUG
#include <Standard_ConstructionError.hxx>
#include <Standard_Integer.hxx>
#include <TDF_AttributeDeltaList.hxx>
#include <TCollection_ExtendedString.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <TDF_LabelList.hxx>
#include <Standard_OStream.hxx>
class TDF_Delta;
-DEFINE_STANDARD_HANDLE(TDF_Delta, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TDF_Delta, Standard_Transient)
//! A set of AttributeDelta for a given transaction
//! number and reference time number.
//! A delta set is available at <aSourceTime>. If
//! applied, it restores the TDF_Data in the state it
//! was at <aTargetTime>.
-class TDF_Delta : public MMgt_TShared
+class TDF_Delta : public Standard_Transient
{
public:
friend class TDF_Data;
- DEFINE_STANDARD_RTTIEXT(TDF_Delta,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TDF_Delta,Standard_Transient)
protected:
#include <TDF_Label.hxx>
#include <TDF_RelocationTable.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TDF_RelocationTable,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TDF_RelocationTable,Standard_Transient)
//=======================================================================
//function : TDF_RelocationTable
#include <TDF_LabelDataMap.hxx>
#include <TDF_AttributeDataMap.hxx>
#include <TColStd_IndexedDataMapOfTransientTransient.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TDF_LabelMap.hxx>
#include <TDF_AttributeMap.hxx>
#include <Standard_OStream.hxx>
class TDF_RelocationTable;
-DEFINE_STANDARD_HANDLE(TDF_RelocationTable, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TDF_RelocationTable, Standard_Transient)
//! This is a relocation dictionnary between source
//! and target labels, attributes or any
//!
//! Look at SelfRelocate method for more explanation
//! about self relocation behavior of this class.
-class TDF_RelocationTable : public MMgt_TShared
+class TDF_RelocationTable : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TDF_RelocationTable,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TDF_RelocationTable,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TDataStd_HDataMapOfStringByte.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TDataStd_HDataMapOfStringByte,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TDataStd_HDataMapOfStringByte,Standard_Transient)
//=======================================================================
//function : TDataStd_HDataMapOfStringByte
#include <Standard_Type.hxx>
#include <TDataStd_DataMapOfStringByte.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
//! Extension of TDataStd_DataMapOfStringByte class
//! to be manipulated by handle.
-class TDataStd_HDataMapOfStringByte : public MMgt_TShared
+class TDataStd_HDataMapOfStringByte : public Standard_Transient
{
- DEFINE_STANDARD_RTTIEXT(TDataStd_HDataMapOfStringByte, MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TDataStd_HDataMapOfStringByte, Standard_Transient)
public:
Standard_EXPORT TDataStd_HDataMapOfStringByte(const Standard_Integer NbBuckets = 1);
};
-DEFINE_STANDARD_HANDLE(TDataStd_HDataMapOfStringByte, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TDataStd_HDataMapOfStringByte, Standard_Transient)
#endif // _TDataStd_HDataMapOfStringByte_HeaderFile
#include <Standard_Type.hxx>
#include <TDataStd_HDataMapOfStringHArray1OfInteger.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TDataStd_HDataMapOfStringHArray1OfInteger,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TDataStd_HDataMapOfStringHArray1OfInteger,Standard_Transient)
//=======================================================================
//function : TDataStd_HDataMapOfStringHArray1OfInteger
#include <Standard_Type.hxx>
#include <TDataStd_DataMapOfStringHArray1OfInteger.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
//! Extension of TDataStd_DataMapOfStringHArray1OfInteger class
//! to be manipulated by handle.
-class TDataStd_HDataMapOfStringHArray1OfInteger : public MMgt_TShared
+class TDataStd_HDataMapOfStringHArray1OfInteger : public Standard_Transient
{
- DEFINE_STANDARD_RTTIEXT(TDataStd_HDataMapOfStringHArray1OfInteger, MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TDataStd_HDataMapOfStringHArray1OfInteger, Standard_Transient)
public:
Standard_EXPORT TDataStd_HDataMapOfStringHArray1OfInteger(const Standard_Integer NbBuckets = 1);
};
-DEFINE_STANDARD_HANDLE(TDataStd_HDataMapOfStringHArray1OfInteger, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TDataStd_HDataMapOfStringHArray1OfInteger, Standard_Transient)
#endif // _TDataStd_HDataMapOfStringHArray1OfInteger_HeaderFile
#include <Standard_Type.hxx>
#include <TDataStd_HDataMapOfStringHArray1OfReal.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TDataStd_HDataMapOfStringHArray1OfReal,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TDataStd_HDataMapOfStringHArray1OfReal,Standard_Transient)
//=======================================================================
//function : TDataStd_HDataMapOfStringHArray1OfReal
#include <Standard_Type.hxx>
#include <TDataStd_DataMapOfStringHArray1OfReal.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
//! Extension of TDataStd_DataMapOfStringHArray1OfReal class
//! to be manipulated by handle.
-class TDataStd_HDataMapOfStringHArray1OfReal : public MMgt_TShared
+class TDataStd_HDataMapOfStringHArray1OfReal : public Standard_Transient
{
- DEFINE_STANDARD_RTTIEXT(TDataStd_HDataMapOfStringHArray1OfReal, MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TDataStd_HDataMapOfStringHArray1OfReal, Standard_Transient)
public:
Standard_EXPORT TDataStd_HDataMapOfStringHArray1OfReal(const Standard_Integer NbBuckets = 1);
};
-DEFINE_STANDARD_HANDLE(TDataStd_HDataMapOfStringHArray1OfReal, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TDataStd_HDataMapOfStringHArray1OfReal, Standard_Transient)
#endif // _TDataStd_HDataMapOfStringHArray1OfReal_HeaderFile
#include <Standard_Type.hxx>
#include <TDataStd_HDataMapOfStringInteger.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TDataStd_HDataMapOfStringInteger,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TDataStd_HDataMapOfStringInteger,Standard_Transient)
//=======================================================================
//function : TDataStd_HDataMapOfStringInteger
#include <Standard_Type.hxx>
#include <TColStd_DataMapOfStringInteger.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
//! Extension of TColStd_DataMapOfStringInteger class
//! to be manipulated by handle.
-class TDataStd_HDataMapOfStringInteger : public MMgt_TShared
+class TDataStd_HDataMapOfStringInteger : public Standard_Transient
{
- DEFINE_STANDARD_RTTIEXT(TDataStd_HDataMapOfStringInteger, MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TDataStd_HDataMapOfStringInteger, Standard_Transient)
public:
Standard_EXPORT TDataStd_HDataMapOfStringInteger(const Standard_Integer NbBuckets = 1);
};
-DEFINE_STANDARD_HANDLE(TDataStd_HDataMapOfStringInteger, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TDataStd_HDataMapOfStringInteger, Standard_Transient)
#endif // _TDataStd_HDataMapOfStringInteger_HeaderFile
#include <Standard_Type.hxx>
#include <TDataStd_HDataMapOfStringReal.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TDataStd_HDataMapOfStringReal,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TDataStd_HDataMapOfStringReal,Standard_Transient)
//=======================================================================
//function : TDataStd_HDataMapOfStringReal
#include <Standard_Type.hxx>
#include <TDataStd_DataMapOfStringReal.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
//! Extension of TDataStd_DataMapOfStringReal class
//! to be manipulated by handle.
-class TDataStd_HDataMapOfStringReal : public MMgt_TShared
+class TDataStd_HDataMapOfStringReal : public Standard_Transient
{
- DEFINE_STANDARD_RTTIEXT(TDataStd_HDataMapOfStringReal, MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TDataStd_HDataMapOfStringReal, Standard_Transient)
public:
Standard_EXPORT TDataStd_HDataMapOfStringReal(const Standard_Integer NbBuckets = 1);
};
-DEFINE_STANDARD_HANDLE(TDataStd_HDataMapOfStringReal, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TDataStd_HDataMapOfStringReal, Standard_Transient)
#endif // _TDataStd_HDataMapOfStringReal_HeaderFile
#include <Standard_Type.hxx>
#include <TDataStd_HDataMapOfStringString.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TDataStd_HDataMapOfStringString,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TDataStd_HDataMapOfStringString,Standard_Transient)
//=======================================================================
//function : TDataStd_HDataMapOfStringString
#include <Standard_Type.hxx>
#include <TDataStd_DataMapOfStringString.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
//! Extension of TDataStd_DataMapOfStringString class
//! to be manipulated by handle.
-class TDataStd_HDataMapOfStringString : public MMgt_TShared
+class TDataStd_HDataMapOfStringString : public Standard_Transient
{
- DEFINE_STANDARD_RTTIEXT(TDataStd_HDataMapOfStringString, MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TDataStd_HDataMapOfStringString, Standard_Transient)
public:
Standard_EXPORT TDataStd_HDataMapOfStringString(const Standard_Integer NbBuckets = 1);
};
-DEFINE_STANDARD_HANDLE(TDataStd_HDataMapOfStringString, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TDataStd_HDataMapOfStringString, Standard_Transient)
#endif // _TDataStd_HDataMapOfStringString_HeaderFile
#include <TDocStd_ApplicationDelta.hxx>
#include <TDocStd_Document.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TDocStd_ApplicationDelta,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TDocStd_ApplicationDelta,Standard_Transient)
//=======================================================================
//function : TDocStd_ApplicationDelta
#include <TDocStd_SequenceOfDocument.hxx>
#include <TCollection_ExtendedString.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_OStream.hxx>
class TCollection_ExtendedString;
class TDocStd_ApplicationDelta;
-DEFINE_STANDARD_HANDLE(TDocStd_ApplicationDelta, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TDocStd_ApplicationDelta, Standard_Transient)
-class TDocStd_ApplicationDelta : public MMgt_TShared
+class TDocStd_ApplicationDelta : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TDocStd_ApplicationDelta,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TDocStd_ApplicationDelta,Standard_Transient)
protected:
#include <TDocStd_Document.hxx>
#include <TDocStd_MultiTransactionManager.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TDocStd_MultiTransactionManager,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TDocStd_MultiTransactionManager,Standard_Transient)
//=======================================================================
//function : TDocStd_MultiTransactionManager
#include <TDocStd_SequenceOfApplicationDelta.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_OStream.hxx>
class TCollection_ExtendedString;
class TDocStd_Document;
class TDocStd_MultiTransactionManager;
-DEFINE_STANDARD_HANDLE(TDocStd_MultiTransactionManager, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TDocStd_MultiTransactionManager, Standard_Transient)
//! Class for synchronization of transactions within multiple documents.
//! Each transaction of this class involvess one transaction in each modified document.
//!
//! NOTE: When you invoke CommitTransaction of multi transaction
//! manager, all nested transaction of its documents will be closed (commited).
-class TDocStd_MultiTransactionManager : public MMgt_TShared
+class TDocStd_MultiTransactionManager : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TDocStd_MultiTransactionManager,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TDocStd_MultiTransactionManager,Standard_Transient)
protected:
#include <TFunction_Driver.hxx>
#include <TFunction_Logbook.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TFunction_Driver,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TFunction_Driver,Standard_Transient)
//=======================================================================
//function : TFunction_Driver
#include <Standard_Type.hxx>
#include <TDF_Label.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
#include <TDF_LabelList.hxx>
class TFunction_Driver;
-DEFINE_STANDARD_HANDLE(TFunction_Driver, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TFunction_Driver, Standard_Transient)
//! This driver class provide services around function
//! execution. One instance of this class is built for
//! attributes of sub-labels of a model.
//! A single instance of this class and each of its
//! subclasses is built for the whole session.
-class TFunction_Driver : public MMgt_TShared
+class TFunction_Driver : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TFunction_Driver,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TFunction_Driver,Standard_Transient)
protected:
#include <TFunction_Driver.hxx>
#include <TFunction_DriverTable.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TFunction_DriverTable,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TFunction_DriverTable,Standard_Transient)
static Handle(TFunction_DriverTable) DT;
#include <TFunction_DataMapOfGUIDDriver.hxx>
#include <TFunction_HArray1OfDataMapOfGUIDDriver.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
#include <Standard_OStream.hxx>
class TFunction_DriverTable;
-DEFINE_STANDARD_HANDLE(TFunction_DriverTable, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TFunction_DriverTable, Standard_Transient)
//! A container for instances of drivers.
//! You create a new instance of TFunction_Driver
//! and use the method AddDriver to load it into the driver table.
-class TFunction_DriverTable : public MMgt_TShared
+class TFunction_DriverTable : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TFunction_DriverTable,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TFunction_DriverTable,Standard_Transient)
protected:
#include <TopoDS.hxx>
#include <TopoDS_Shape.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TNaming_TranslateTool,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TNaming_TranslateTool,Standard_Transient)
//=======================================================================
//function : TNaming_TranslateTool
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TColStd_IndexedDataMapOfTransientTransient.hxx>
class Standard_TypeMismatch;
class TopoDS_Shape;
class TNaming_TranslateTool;
-DEFINE_STANDARD_HANDLE(TNaming_TranslateTool, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TNaming_TranslateTool, Standard_Transient)
//! tool to copy underlying TShape of a Shape.
//! The TranslateTool class is provided to support the
//! translation of topological data structures Transient
//! to Transient.
-class TNaming_TranslateTool : public MMgt_TShared
+class TNaming_TranslateTool : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TNaming_TranslateTool,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TNaming_TranslateTool,Standard_Transient)
protected:
//purpose :
//=======================================================================
-class TObj_Assistant_UnknownType : public MMgt_TShared
+class TObj_Assistant_UnknownType : public Standard_Transient
{
public:
// Empty constructor
// CASCADE RTTI
- DEFINE_STANDARD_RTTI_INLINE(TObj_Assistant_UnknownType,MMgt_TShared)
+ DEFINE_STANDARD_RTTI_INLINE(TObj_Assistant_UnknownType,Standard_Transient)
};
// Define handle class for TObj_Assistant_UnknownType
-DEFINE_STANDARD_HANDLE(TObj_Assistant_UnknownType,MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TObj_Assistant_UnknownType,Standard_Transient)
//=======================================================================
//! Basic CASCADE definitions
#include <Standard_Type.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TCollection_ExtendedString.hxx>
#include <TCollection_HExtendedString.hxx>
#include <Standard_Failure.hxx>
#include <Message_Msg.hxx>
#include <OSD_OpenFile.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TObj_Model,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TObj_Model,Standard_Transient)
#ifdef _MSC_VER
#include <io.h>
class TObj_Application;
class TObj_Model;
-DEFINE_STANDARD_HANDLE(TObj_Model,MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TObj_Model,Standard_Transient)
/**
* Base class for OCAF based models.
* Provides default implementation for many methods.
*/
-class TObj_Model : public MMgt_TShared
+class TObj_Model : public Standard_Transient
{
protected:
public:
//! CASCADE RTTI
- DEFINE_STANDARD_RTTIEXT(TObj_Model,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TObj_Model,Standard_Transient)
};
//! The Model Handle is defined in a separate header file
#include <TDF_TagSource.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TObj_Object,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TObj_Object,Standard_Transient)
//=======================================================================
//function : Constructor
#include <TColStd_HArray1OfExtendedString.hxx>
class TObj_Object;
-DEFINE_STANDARD_HANDLE(TObj_Object,MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TObj_Object,Standard_Transient)
//! Basis class for transient objects in OCAF-based models
-class TObj_Object : public MMgt_TShared
+class TObj_Object : public Standard_Transient
{
public:
enum TypeFlags //!< Flags that define type-specific behaviour of objects
public:
//! CASCADE RTTI
- DEFINE_STANDARD_RTTIEXT(TObj_Object,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TObj_Object,Standard_Transient)
};
//! Define handle in separate file
#include <TObj_Object.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TObj_ObjectIterator,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TObj_ObjectIterator,Standard_Transient)
//=======================================================================
//function : More
* (implements TObj_ObjectIterator interface)
*/
-class TObj_ObjectIterator : public MMgt_TShared
+class TObj_ObjectIterator : public Standard_Transient
{
public:
/*
public:
//! CASCADE RTTI
- DEFINE_STANDARD_RTTIEXT(TObj_ObjectIterator,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TObj_ObjectIterator,Standard_Transient)
};
//! Define handle class for TObj_ObjectIterator
-DEFINE_STANDARD_HANDLE(TObj_ObjectIterator,MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TObj_ObjectIterator,Standard_Transient)
#endif
#include <TDF_Label.hxx>
#include <TPrsStd_Driver.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TPrsStd_Driver,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TPrsStd_Driver,Standard_Transient)
TPrsStd_Driver::TPrsStd_Driver()
{}
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
class TDF_Label;
class AIS_InteractiveObject;
class TPrsStd_Driver;
-DEFINE_STANDARD_HANDLE(TPrsStd_Driver, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TPrsStd_Driver, Standard_Transient)
//! Driver for AIS
//! ==============
//! values (if Null) or Update (if !Null) an AIS_InteractiveObject
//! . Resources are found in attributes associated to a given
//! label.
-class TPrsStd_Driver : public MMgt_TShared
+class TPrsStd_Driver : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TPrsStd_Driver,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TPrsStd_Driver,Standard_Transient)
protected:
#include <TPrsStd_PlaneDriver.hxx>
#include <TPrsStd_PointDriver.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TPrsStd_DriverTable,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TPrsStd_DriverTable,Standard_Transient)
static Handle(TPrsStd_DriverTable) drivertable;
#include <Standard_Type.hxx>
#include <TPrsStd_DataMapOfGUIDDriver.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
class Standard_GUID;
class TPrsStd_Driver;
class TPrsStd_DriverTable;
-DEFINE_STANDARD_HANDLE(TPrsStd_DriverTable, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TPrsStd_DriverTable, Standard_Transient)
//! This class is a container to record (AddDriver)
//! binding between GUID and TPrsStd_Driver.
//! You create a new instance of TPrsStd_Driver
//! and use the method AddDriver to load it into the driver table. the method
-class TPrsStd_DriverTable : public MMgt_TShared
+class TPrsStd_DriverTable : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TPrsStd_DriverTable,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TPrsStd_DriverTable,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TopLoc_Datum3D.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TopLoc_Datum3D,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TopLoc_Datum3D,Standard_Transient)
//=======================================================================
//function : TopLoc_Datum3D
#include <Standard_Type.hxx>
#include <gp_Trsf.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_OStream.hxx>
class Standard_ConstructionError;
class gp_Trsf;
class TopLoc_Datum3D;
-DEFINE_STANDARD_HANDLE(TopLoc_Datum3D, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TopLoc_Datum3D, Standard_Transient)
//! Describes a coordinate transformation, i.e. a change
//! to an elementary 3D coordinate system, or position in 3D space.
//! A Datum3D is always described relative to the default datum.
//! The default datum is described relative to itself: its
//! origin is (0,0,0), and its axes are (1,0,0) (0,1,0) (0,0,1).
-class TopLoc_Datum3D : public MMgt_TShared
+class TopLoc_Datum3D : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TopLoc_Datum3D,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TopLoc_Datum3D,Standard_Transient)
protected:
#include <TopLoc_SListNodeOfItemLocation.hxx>
#include <TopLoc_SListOfItemLocation.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TopLoc_SListNodeOfItemLocation,MMgt_TShared)
\ No newline at end of file
+IMPLEMENT_STANDARD_RTTIEXT(TopLoc_SListNodeOfItemLocation,Standard_Transient)
\ No newline at end of file
#include <TopLoc_SListOfItemLocation.hxx>
#include <TopLoc_ItemLocation.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TopLoc_ItemLocation;
class TopLoc_SListOfItemLocation;
class TopLoc_SListNodeOfItemLocation;
-DEFINE_STANDARD_HANDLE(TopLoc_SListNodeOfItemLocation, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TopLoc_SListNodeOfItemLocation, Standard_Transient)
-class TopLoc_SListNodeOfItemLocation : public MMgt_TShared
+class TopLoc_SListNodeOfItemLocation : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TopLoc_SListNodeOfItemLocation,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TopLoc_SListNodeOfItemLocation,Standard_Transient)
protected:
#include <TopOpeBRep_VPointInterIterator.hxx>
#include <TopOpeBRepTool_ShapeTool.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TopOpeBRep_FFDumper,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TopOpeBRep_FFDumper,Standard_Transient)
#ifdef OCCT_DEBUG
static TCollection_AsciiString PRODINP("dinp ");
#include <TopoDS_Face.hxx>
#include <TopTools_DataMapOfShapeInteger.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TopOpeBRepDS_Kind.hxx>
#include <Standard_Boolean.hxx>
class TopOpeBRep_LineInter;
class TopOpeBRep_FFDumper;
-DEFINE_STANDARD_HANDLE(TopOpeBRep_FFDumper, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TopOpeBRep_FFDumper, Standard_Transient)
-class TopOpeBRep_FFDumper : public MMgt_TShared
+class TopOpeBRep_FFDumper : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TopOpeBRep_FFDumper,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TopOpeBRep_FFDumper,Standard_Transient)
protected:
#include <TopOpeBRepTool_PROJECT.hxx>
#include <TopOpeBRepTool_ShapeTool.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TopOpeBRep_Hctxee2d,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TopOpeBRep_Hctxee2d,Standard_Transient)
#ifdef OCCT_DEBUG
#include <GeomTools_SurfaceSet.hxx>
#include <TopoDS_Edge.hxx>
#include <Geom2dAdaptor_Curve.hxx>
#include <IntRes2d_Domain.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
class TopoDS_Edge;
class BRepAdaptor_Surface;
class TopOpeBRep_Hctxee2d;
-DEFINE_STANDARD_HANDLE(TopOpeBRep_Hctxee2d, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TopOpeBRep_Hctxee2d, Standard_Transient)
-class TopOpeBRep_Hctxee2d : public MMgt_TShared
+class TopOpeBRep_Hctxee2d : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TopOpeBRep_Hctxee2d,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TopOpeBRep_Hctxee2d,Standard_Transient)
protected:
#include <TopOpeBRep_Hctxff2d.hxx>
#include <TopOpeBRepTool_ShapeTool.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TopOpeBRep_Hctxff2d,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TopOpeBRep_Hctxff2d,Standard_Transient)
//=======================================================================
//function : TopOpeBRep_Hctxff2d
#include <GeomAbs_SurfaceType.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Real.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
class BRepAdaptor_HSurface;
class TopoDS_Face;
class TopOpeBRep_Hctxff2d;
-DEFINE_STANDARD_HANDLE(TopOpeBRep_Hctxff2d, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TopOpeBRep_Hctxff2d, Standard_Transient)
-class TopOpeBRep_Hctxff2d : public MMgt_TShared
+class TopOpeBRep_Hctxff2d : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TopOpeBRep_Hctxff2d,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TopOpeBRep_Hctxff2d,Standard_Transient)
protected:
#include <TopTools_ListOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TopOpeBRepBuild_HBuilder,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TopOpeBRepBuild_HBuilder,Standard_Transient)
//=======================================================================
//function : TopOpeBRepBuild_HBuilder
#include <Standard_Boolean.hxx>
#include <TopoDS_Shape.hxx>
#include <TColStd_ListOfInteger.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TopAbs_State.hxx>
#include <TopTools_ListOfShape.hxx>
#include <Standard_Integer.hxx>
class TopOpeBRepBuild_HBuilder;
-DEFINE_STANDARD_HANDLE(TopOpeBRepBuild_HBuilder, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TopOpeBRepBuild_HBuilder, Standard_Transient)
//! The HBuilder algorithm constructs topological
//! objects from an existing topology and new
//! the existing topologies are the parts involved in
//! the topological operation and the new geometries
//! are the intersection lines and points.
-class TopOpeBRepBuild_HBuilder : public MMgt_TShared
+class TopOpeBRepBuild_HBuilder : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TopOpeBRepBuild_HBuilder,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TopOpeBRepBuild_HBuilder,Standard_Transient)
protected:
#include <TopOpeBRepBuild_BlockIterator.hxx>
#include <TopOpeBRepBuild_Loop.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TopOpeBRepBuild_Loop,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TopOpeBRepBuild_Loop,Standard_Transient)
//=======================================================================
//function : TopOpeBRepBuild_Loop
#include <Standard_Boolean.hxx>
#include <TopoDS_Shape.hxx>
#include <TopOpeBRepBuild_BlockIterator.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TopoDS_Shape;
class TopOpeBRepBuild_BlockIterator;
class TopOpeBRepBuild_Loop;
-DEFINE_STANDARD_HANDLE(TopOpeBRepBuild_Loop, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TopOpeBRepBuild_Loop, Standard_Transient)
//! a Loop is an existing shape (Shell,Wire) or a set
//! of shapes (Faces,Edges) which are connex.
//! a set of connex shape is represented by a BlockIterator
-class TopOpeBRepBuild_Loop : public MMgt_TShared
+class TopOpeBRepBuild_Loop : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TopOpeBRepBuild_Loop,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TopOpeBRepBuild_Loop,Standard_Transient)
protected:
#include <TopOpeBRepDS_Interference.hxx>
#include <TopOpeBRepDS_ListIteratorOfListOfInterference.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TopOpeBRepDS_Association,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TopOpeBRepDS_Association,Standard_Transient)
//=======================================================================
//function : Contains
#include <Standard_Type.hxx>
#include <TopOpeBRepDS_DataMapOfInterferenceListOfInterference.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TopOpeBRepDS_ListOfInterference.hxx>
#include <Standard_Boolean.hxx>
class TopOpeBRepDS_Interference;
class TopOpeBRepDS_Association;
-DEFINE_STANDARD_HANDLE(TopOpeBRepDS_Association, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TopOpeBRepDS_Association, Standard_Transient)
-class TopOpeBRepDS_Association : public MMgt_TShared
+class TopOpeBRepDS_Association : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TopOpeBRepDS_Association,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TopOpeBRepDS_Association,Standard_Transient)
protected:
#include <TopTools_ListOfShape.hxx>
#include <string.h>
-IMPLEMENT_STANDARD_RTTIEXT(TopOpeBRepDS_Check,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TopOpeBRepDS_Check,Standard_Transient)
//=======================================================================
//function : Create
#include <Standard_Type.hxx>
#include <TopOpeBRepDS_DataMapOfCheckStatus.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <TopOpeBRepDS_ListOfInterference.hxx>
#include <Standard_Integer.hxx>
class TopOpeBRepDS_Check;
-DEFINE_STANDARD_HANDLE(TopOpeBRepDS_Check, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TopOpeBRepDS_Check, Standard_Transient)
//! a tool verifing integrity and structure of DS
-class TopOpeBRepDS_Check : public MMgt_TShared
+class TopOpeBRepDS_Check : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TopOpeBRepDS_Check,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TopOpeBRepDS_Check,Standard_Transient)
protected:
#include <TopOpeBRepDS_Interference.hxx>
#include <TopOpeBRepDS_ListIteratorOfListOfInterference.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TopOpeBRepDS_GapTool,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TopOpeBRepDS_GapTool,Standard_Transient)
//=======================================================================
//function : TopOpeBRepDS_GapTool
#include <TopOpeBRepDS_DataMapOfIntegerListOfInterference.hxx>
#include <TopOpeBRepDS_DataMapOfInterferenceShape.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TopOpeBRepDS_ListOfInterference.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
class TopOpeBRepDS_GapTool;
-DEFINE_STANDARD_HANDLE(TopOpeBRepDS_GapTool, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TopOpeBRepDS_GapTool, Standard_Transient)
-class TopOpeBRepDS_GapTool : public MMgt_TShared
+class TopOpeBRepDS_GapTool : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TopOpeBRepDS_GapTool,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TopOpeBRepDS_GapTool,Standard_Transient)
protected:
#include <TopOpeBRepTool_ShapeExplorer.hxx>
#include <TopTools_ListOfShape.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TopOpeBRepDS_HDataStructure,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TopOpeBRepDS_HDataStructure,Standard_Transient)
static void FUN_HDS_data(const Handle(TopOpeBRepDS_Interference)& I,
TopOpeBRepDS_Kind& GT1,Standard_Integer& G1,
#include <TopOpeBRepDS_DataStructure.hxx>
#include <Standard_Boolean.hxx>
#include <TCollection_AsciiString.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TopAbs_ShapeEnum.hxx>
#include <Standard_Integer.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
class TopOpeBRepDS_HDataStructure;
-DEFINE_STANDARD_HANDLE(TopOpeBRepDS_HDataStructure, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TopOpeBRepDS_HDataStructure, Standard_Transient)
-class TopOpeBRepDS_HDataStructure : public MMgt_TShared
+class TopOpeBRepDS_HDataStructure : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TopOpeBRepDS_HDataStructure,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TopOpeBRepDS_HDataStructure,Standard_Transient)
protected:
#include <TopOpeBRepDS_Interference.hxx>
#include <TopOpeBRepDS_Transition.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TopOpeBRepDS_Interference,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TopOpeBRepDS_Interference,Standard_Transient)
//=======================================================================
//function : TopOpeBRepDS_Interference
#include <TopOpeBRepDS_Transition.hxx>
#include <Standard_Integer.hxx>
#include <TopOpeBRepDS_Kind.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_OStream.hxx>
class TopOpeBRepDS_Transition;
class TopOpeBRepDS_Interference;
-DEFINE_STANDARD_HANDLE(TopOpeBRepDS_Interference, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TopOpeBRepDS_Interference, Standard_Transient)
//! An interference is the description of the
//! attachment of a new geometry on a geometry. For
//!
//! - Geometry : Index in the data structure of the
//! geometry.
-class TopOpeBRepDS_Interference : public MMgt_TShared
+class TopOpeBRepDS_Interference : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TopOpeBRepDS_Interference,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TopOpeBRepDS_Interference,Standard_Transient)
protected:
#include <TopOpeBRepDS_define.hxx>
#include <TopOpeBRepDS_Marker.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TopOpeBRepDS_Marker,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TopOpeBRepDS_Marker,Standard_Transient)
//#include <TopExp.hxx>
//#include <TopTools_IndexedMapOfShape.hxx>
#include <TColStd_HArray1OfBoolean.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Address.hxx>
class TopOpeBRepDS_Marker;
-DEFINE_STANDARD_HANDLE(TopOpeBRepDS_Marker, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TopOpeBRepDS_Marker, Standard_Transient)
-class TopOpeBRepDS_Marker : public MMgt_TShared
+class TopOpeBRepDS_Marker : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TopOpeBRepDS_Marker,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TopOpeBRepDS_Marker,Standard_Transient)
protected:
#include <TopOpeBRepTool_define.hxx>
#include <TopOpeBRepTool_HBoxTool.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TopOpeBRepTool_HBoxTool,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TopOpeBRepTool_HBoxTool,Standard_Transient)
#ifdef OCCT_DEBUG
#define TBOX TopOpeBRepTool_GettraceBOX()
#include <Standard_Type.hxx>
#include <TopOpeBRepTool_IndexedDataMapOfShapeBox.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TopAbs_ShapeEnum.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
class TopOpeBRepTool_HBoxTool;
-DEFINE_STANDARD_HANDLE(TopOpeBRepTool_HBoxTool, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TopOpeBRepTool_HBoxTool, Standard_Transient)
-class TopOpeBRepTool_HBoxTool : public MMgt_TShared
+class TopOpeBRepTool_HBoxTool : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TopOpeBRepTool_HBoxTool,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TopOpeBRepTool_HBoxTool,Standard_Transient)
protected:
#include <TopoDS_HShape.hxx>
#include <TopoDS_Shape.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TopoDS_HShape,MMgt_TShared)
\ No newline at end of file
+IMPLEMENT_STANDARD_RTTIEXT(TopoDS_HShape,Standard_Transient)
\ No newline at end of file
#include <Standard_Type.hxx>
#include <TopoDS_Shape.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TopoDS_Shape;
class TopoDS_HShape;
-DEFINE_STANDARD_HANDLE(TopoDS_HShape, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TopoDS_HShape, Standard_Transient)
//! Class to manipulate a Shape with handle.
-class TopoDS_HShape : public MMgt_TShared
+class TopoDS_HShape : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TopoDS_HShape,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TopoDS_HShape,Standard_Transient)
protected:
#include <TopoDS_Iterator.hxx>
#include <TopoDS_TShape.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TopoDS_TShape,MMgt_TShared)
\ No newline at end of file
+IMPLEMENT_STANDARD_RTTIEXT(TopoDS_TShape,Standard_Transient)
\ No newline at end of file
#include <TopoDS_ListOfShape.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <TopAbs_ShapeEnum.hxx>
#endif
class TopoDS_TShape;
-DEFINE_STANDARD_HANDLE(TopoDS_TShape, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TopoDS_TShape, Standard_Transient)
//! A TShape is a topological structure describing a
//! set of points in a 2D or 3D space.
//! Users have no direct access to the classes derived
//! from TShape. They handle them with the classes
//! derived from Shape.
-class TopoDS_TShape : public MMgt_TShared
+class TopoDS_TShape : public Standard_Transient
{
public:
friend class TopoDS_Builder;
- DEFINE_STANDARD_RTTIEXT(TopoDS_TShape,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TopoDS_TShape,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Transfer_HSequenceOfFinder.hxx>
#include <Transfer_TransferMapOfProcessForFinder.hxx>
class Transfer_ActorOfProcessForFinder;
-DEFINE_STANDARD_HANDLE(Transfer_ActorOfProcessForFinder, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Transfer_ActorOfProcessForFinder, Standard_Transient)
-class Transfer_ActorOfProcessForFinder : public MMgt_TShared
+class Transfer_ActorOfProcessForFinder : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTI_INLINE(Transfer_ActorOfProcessForFinder,MMgt_TShared)
+ DEFINE_STANDARD_RTTI_INLINE(Transfer_ActorOfProcessForFinder,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TColStd_MapTransientHasher.hxx>
#include <TColStd_HSequenceOfTransient.hxx>
#include <Transfer_TransferMapOfProcessForTransient.hxx>
class Transfer_ActorOfProcessForTransient;
-DEFINE_STANDARD_HANDLE(Transfer_ActorOfProcessForTransient, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Transfer_ActorOfProcessForTransient, Standard_Transient)
-class Transfer_ActorOfProcessForTransient : public MMgt_TShared
+class Transfer_ActorOfProcessForTransient : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTI_INLINE(Transfer_ActorOfProcessForTransient,MMgt_TShared)
+ DEFINE_STANDARD_RTTI_INLINE(Transfer_ActorOfProcessForTransient,Standard_Transient)
protected:
#include <Transfer_TransferFailure.hxx>
#include <Transfer_VoidBinder.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Transfer_Binder,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Transfer_Binder,Standard_Transient)
//=======================================================================
//function : Transfer_Binder
#include <Transfer_StatusResult.hxx>
#include <Transfer_StatusExec.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Type.hxx>
#include <Standard_CString.hxx>
#endif
class Transfer_Binder;
-DEFINE_STANDARD_HANDLE(Transfer_Binder, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Transfer_Binder, Standard_Transient)
//! A Binder is an auxiliary object to Map the Result of the
//! Transfer of a given Object : it records the Result of the
//!
//! In addition to the Result, a Binder can bring a list of
//! Attributes, which are additional data, each of them has a name
-class Transfer_Binder : public MMgt_TShared
+class Transfer_Binder : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Transfer_Binder,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Transfer_Binder,Standard_Transient)
protected:
#include <TCollection_HAsciiString.hxx>
#include <Transfer_Finder.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Transfer_Finder,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Transfer_Finder,Standard_Transient)
void Transfer_Finder::SetHashCode (const Standard_Integer code)
{ thecode = code; }
#include <NCollection_DataMap.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Type.hxx>
#include <Standard_CString.hxx>
class Transfer_Finder;
-DEFINE_STANDARD_HANDLE(Transfer_Finder, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Transfer_Finder, Standard_Transient)
//! a Finder allows to map any kind of object as a Key for a Map.
//! This works by defining, for a Hash Code, that of the real Key,
//! not of the Finder which acts only as an intermediate.
//! When a Map asks for the HashCode of a Finder, this one returns
//! the code it has determined at creation time
-class Transfer_Finder : public MMgt_TShared
+class Transfer_Finder : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Transfer_Finder,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Transfer_Finder,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <Transfer_MapContainer.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Transfer_MapContainer,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Transfer_MapContainer,Standard_Transient)
Transfer_MapContainer::Transfer_MapContainer()
{
#include <Standard_Type.hxx>
#include <TColStd_DataMapOfTransientTransient.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class Transfer_MapContainer;
-DEFINE_STANDARD_HANDLE(Transfer_MapContainer, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Transfer_MapContainer, Standard_Transient)
-class Transfer_MapContainer : public MMgt_TShared
+class Transfer_MapContainer : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Transfer_MapContainer,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Transfer_MapContainer,Standard_Transient)
protected:
class Transfer_ProcessForFinder;
-DEFINE_STANDARD_HANDLE(Transfer_ProcessForFinder, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Transfer_ProcessForFinder, Standard_Transient)
-class Transfer_ProcessForFinder : public MMgt_TShared
+class Transfer_ProcessForFinder : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTI_INLINE(Transfer_ProcessForFinder,MMgt_TShared)
+ DEFINE_STANDARD_RTTI_INLINE(Transfer_ProcessForFinder,Standard_Transient)
protected:
class Transfer_ProcessForTransient;
-DEFINE_STANDARD_HANDLE(Transfer_ProcessForTransient, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Transfer_ProcessForTransient, Standard_Transient)
//! Manages Transfer of Transient Objects. Produces also
//! ActorOfTransientProcess (deferred class),
//! TransferMapOfTransientProcess (internally used)
//! Normally uses as TransientProcess, which adds some specifics
-class Transfer_ProcessForTransient : public MMgt_TShared
+class Transfer_ProcessForTransient : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTI_INLINE(Transfer_ProcessForTransient,MMgt_TShared)
+ DEFINE_STANDARD_RTTI_INLINE(Transfer_ProcessForTransient,Standard_Transient)
protected:
#include <Transfer_ResultFromTransient.hxx>
#include <Transfer_TransientProcess.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Transfer_ResultFromModel,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Transfer_ResultFromModel,Standard_Transient)
Transfer_ResultFromModel::Transfer_ResultFromModel ()
{ themnum = 0; themchk = Interface_CheckAny; }
#include <TCollection_AsciiString.hxx>
#include <Standard_Integer.hxx>
#include <Interface_CheckStatus.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
#include <Standard_Boolean.hxx>
#include <TColStd_HSequenceOfTransient.hxx>
class Transfer_ResultFromModel;
-DEFINE_STANDARD_HANDLE(Transfer_ResultFromModel, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Transfer_ResultFromModel, Standard_Transient)
//! ResultFromModel is used to store a final result stored in a
//! TransientProcess, respectfully to its structuration in scopes
//! by designating a starting entity
//! - Fill back the TransientProcess from a ResultFromModel, as it
//! were filled by the operation which filled it the first time
-class Transfer_ResultFromModel : public MMgt_TShared
+class Transfer_ResultFromModel : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Transfer_ResultFromModel,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Transfer_ResultFromModel,Standard_Transient)
protected:
#include <Transfer_ResultFromTransient.hxx>
#include <Transfer_TransientProcess.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Transfer_ResultFromTransient,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Transfer_ResultFromTransient,Standard_Transient)
static Handle(Interface_Check) voidcheck = new Interface_Check;
#include <Standard_Type.hxx>
#include <TColStd_HSequenceOfTransient.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Interface_CheckStatus.hxx>
#include <Standard_Integer.hxx>
class Transfer_ResultFromTransient;
-DEFINE_STANDARD_HANDLE(Transfer_ResultFromTransient, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Transfer_ResultFromTransient, Standard_Transient)
//! This class, in conjunction with ResultFromModel, allows to
//! record the result of a transfer initially stored in a
//! the result and checks) plus a list of "sub-results", which
//! have been recorded in the TrabsientProcess, under scope
//! attached to the starting transient.
-class Transfer_ResultFromTransient : public MMgt_TShared
+class Transfer_ResultFromTransient : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Transfer_ResultFromTransient,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Transfer_ResultFromTransient,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <TransferBRep_TransferResultInfo.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(TransferBRep_TransferResultInfo,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(TransferBRep_TransferResultInfo,Standard_Transient)
//=======================================================================
//function : TransferBRep_TransferResultInfo
#include <Standard_Type.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class TransferBRep_TransferResultInfo;
-DEFINE_STANDARD_HANDLE(TransferBRep_TransferResultInfo, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(TransferBRep_TransferResultInfo, Standard_Transient)
//! Data structure for storing information on transfer result.
//! At the moment it dispatches information for the following types:
//! - no result + warning(s),
//! - no result + fail(s),
//! - no result + warning(s) + fail(s),
-class TransferBRep_TransferResultInfo : public MMgt_TShared
+class TransferBRep_TransferResultInfo : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(TransferBRep_TransferResultInfo,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(TransferBRep_TransferResultInfo,Standard_Transient)
protected:
#include <Units_Operators.hxx>
#include <Units_UnitsDictionary.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Units_Dimensions,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Units_Dimensions,Standard_Transient)
//=======================================================================
//function : Units_Dimensions
#include <Standard_Type.hxx>
#include <Standard_Real.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
class Units_Dimensions;
-DEFINE_STANDARD_HANDLE(Units_Dimensions, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Units_Dimensions, Standard_Transient)
//! This class includes all the methods to create and
//! manipulate the dimensions of the physical
//! quantities.
-class Units_Dimensions : public MMgt_TShared
+class Units_Dimensions : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Units_Dimensions,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Units_Dimensions,Standard_Transient)
protected:
#include <TCollection_HAsciiString.hxx>
#include <Units_Token.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Units_Lexicon,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Units_Lexicon,Standard_Transient)
namespace
{
#include <Standard_Time.hxx>
#include <Units_TokensSequence.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Real.hxx>
class Units_Lexicon;
-DEFINE_STANDARD_HANDLE(Units_Lexicon, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Units_Lexicon, Standard_Transient)
//! This class defines a lexicon useful to analyse and
//! recognize the different key words included in a
//! sentence. The lexicon is stored in a sequence of
//! tokens.
-class Units_Lexicon : public MMgt_TShared
+class Units_Lexicon : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Units_Lexicon,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Units_Lexicon,Standard_Transient)
protected:
#include <Units_Quantity.hxx>
#include <Units_Unit.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Units_Quantity,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Units_Quantity,Standard_Transient)
//=======================================================================
//function : IsEqual
#include <Standard_Type.hxx>
#include <Units_UnitsSequence.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
#include <TCollection_AsciiString.hxx>
#include <Standard_Boolean.hxx>
class Units_Quantity;
-DEFINE_STANDARD_HANDLE(Units_Quantity, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Units_Quantity, Standard_Transient)
//! This class stores in its field all the possible
//! units of all the unit systems for a given physical
//! quantity. Each unit's value is expressed in the
//! S.I. unit system.
-class Units_Quantity : public MMgt_TShared
+class Units_Quantity : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Units_Quantity,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Units_Quantity,Standard_Transient)
protected:
#include <Units_Operators.hxx>
#include <Units_Token.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Units_Token,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Units_Token,Standard_Transient)
//=======================================================================
//function : Units_Token
#include <TCollection_AsciiString.hxx>
#include <Standard_Real.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
class Units_Token;
-DEFINE_STANDARD_HANDLE(Units_Token, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Units_Token, Standard_Transient)
//! This class defines an elementary word contained in
//! a Sentence object.
-class Units_Token : public MMgt_TShared
+class Units_Token : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Units_Token,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Units_Token,Standard_Transient)
protected:
#include <Units_Unit.hxx>
#include <Units_UnitsDictionary.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Units_Unit,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Units_Unit,Standard_Transient)
//=======================================================================
//function : Units_Unit
#include <TColStd_HSequenceOfHAsciiString.hxx>
#include <Standard_Real.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
#include <TCollection_AsciiString.hxx>
#include <Standard_Boolean.hxx>
class Units_Unit;
-DEFINE_STANDARD_HANDLE(Units_Unit, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Units_Unit, Standard_Transient)
//! This class defines an elementary word contained in
//! a physical quantity.
-class Units_Unit : public MMgt_TShared
+class Units_Unit : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Units_Unit,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Units_Unit,Standard_Transient)
protected:
#include <stdio.h>
-IMPLEMENT_STANDARD_RTTIEXT(Units_UnitsDictionary,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Units_UnitsDictionary,Standard_Transient)
//=======================================================================
//function : Units_UnitsDictionary
#include <Standard_Time.hxx>
#include <Units_QuantitiesSequence.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
class Units_UnitsDictionary;
-DEFINE_STANDARD_HANDLE(Units_UnitsDictionary, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Units_UnitsDictionary, Standard_Transient)
//! This class creates a dictionary of all the units
//! you want to know.
-class Units_UnitsDictionary : public MMgt_TShared
+class Units_UnitsDictionary : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Units_UnitsDictionary,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Units_UnitsDictionary,Standard_Transient)
protected:
#include <Units_UnitsSequence.hxx>
#include <Units_UnitsSystem.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Units_UnitsSystem,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Units_UnitsSystem,Standard_Transient)
//=======================================================================
//function : Units_UnitsSystem
#include <Units_QuantitiesSequence.hxx>
#include <TColStd_HSequenceOfInteger.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Real.hxx>
class Units_UnitsSystem;
-DEFINE_STANDARD_HANDLE(Units_UnitsSystem, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Units_UnitsSystem, Standard_Transient)
//! This class allows the user to define his own
//! system of units.
-class Units_UnitsSystem : public MMgt_TShared
+class Units_UnitsSystem : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Units_UnitsSystem,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Units_UnitsSystem,Standard_Transient)
protected:
#include <V3d_View.hxx>
#include <V3d_Viewer.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(V3d_Light,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(V3d_Light,Standard_Transient)
// =======================================================================
// function : V3d_Light
#include <Graphic3d_CLight.hxx>
#include <Graphic3d_Vertex.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Quantity_Color.hxx>
#include <Standard.hxx>
#include <Standard_Boolean.hxx>
class V3d_Viewer;
class V3d_Light;
-DEFINE_STANDARD_HANDLE(V3d_Light, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(V3d_Light, Standard_Transient)
//! Defines services on Light type objects..
//! (base class for AmbientLight and PositionLight)
-class V3d_Light : public MMgt_TShared
+class V3d_Light : public Standard_Transient
{
public:
//! Updates the lights of the view. The view is redrawn.
Standard_EXPORT void V3d_View::UpdateLights() const;
- DEFINE_STANDARD_RTTIEXT(V3d_Light,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(V3d_Light,Standard_Transient)
protected:
#include <Graphic3d_ArrayOfQuadrangles.hxx>
#include <gp_Pln.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(V3d_Plane,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(V3d_Plane,Standard_Transient)
// =======================================================================
// function : V3d_Plane
#include <V3d_View.hxx>
class V3d_Plane;
-DEFINE_STANDARD_HANDLE (V3d_Plane, MMgt_TShared)
+DEFINE_STANDARD_HANDLE (V3d_Plane, Standard_Transient)
//! Obsolete clip plane presentation class.
//! Ported on new core of Graphic3d_ClipPlane approach.
//! @endcode
//! Use interface of this class to modify plane equation synchronously
//! with clipping equation.
-class V3d_Plane : public MMgt_TShared
+class V3d_Plane : public Standard_Transient
{
public:
public:
- DEFINE_STANDARD_RTTIEXT(V3d_Plane,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(V3d_Plane,Standard_Transient)
};
#endif
#include <V3d_UnMapped.hxx>
#include <V3d_Viewer.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(V3d_View,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(V3d_View,Standard_Transient)
#define DEUXPI (2. * M_PI)
#include <Image_PixMap.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Quantity_TypeOfColor.hxx>
class V3d_UnMapped;
class V3d_View;
-DEFINE_STANDARD_HANDLE(V3d_View, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(V3d_View, Standard_Transient)
//! Defines the application object VIEW for the
//! VIEWER application.
//!
//! View->Move(10.,20.,0.,True) (Starting motion)
//! View->Move(15.,-5.,0.,False) (Next motion)
-class V3d_View : public MMgt_TShared
+class V3d_View : public Standard_Transient
{
public:
Standard_EXPORT void DiagnosticInformation (TColStd_IndexedDataMapOfStringString& theDict,
Graphic3d_DiagnosticInfo theFlags) const;
- DEFINE_STANDARD_RTTIEXT(V3d_View,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(V3d_View,Standard_Transient)
protected:
class AIS_InteractiveContext;
class AIS_InteractiveObject;
class TCollection_AsciiString;
-class MMgt_TShared;
+class Standard_Transient;
class Image_PixMap;
class V3d_View;
class V3d_Viewer;
#include <V3d_View.hxx>
#include <ViewerTest_EventManager.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(ViewerTest_EventManager,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(ViewerTest_EventManager,Standard_Transient)
//=======================================================================
//function : ViewerTest_EventManager
#include <Standard_Type.hxx>
#include <Standard_Integer.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
class AIS_InteractiveContext;
class ViewerTest_EventManager;
-DEFINE_STANDARD_HANDLE(ViewerTest_EventManager, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(ViewerTest_EventManager, Standard_Transient)
//! used to manage mouse event (move,select,shiftselect)
//! By default the events are transmitted to interactive context.
-class ViewerTest_EventManager : public MMgt_TShared
+class ViewerTest_EventManager : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(ViewerTest_EventManager,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(ViewerTest_EventManager,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <Vrml_AsciiText.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Vrml_AsciiText,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Vrml_AsciiText,Standard_Transient)
Vrml_AsciiText::Vrml_AsciiText()
{
#include <TColStd_HArray1OfAsciiString.hxx>
#include <Standard_Real.hxx>
#include <Vrml_AsciiTextJustification.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_OStream.hxx>
class Vrml_AsciiText;
-DEFINE_STANDARD_HANDLE(Vrml_AsciiText, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Vrml_AsciiText, Standard_Transient)
//! defines a AsciiText node of VRML specifying geometry shapes.
//! This node represents strings of text characters from ASCII coded
//! bottom in the font set by FontStyle.
//! The default value for the wigth field indicates the natural width
//! should be used for that string.
-class Vrml_AsciiText : public MMgt_TShared
+class Vrml_AsciiText : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Vrml_AsciiText,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Vrml_AsciiText,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <Vrml_Coordinate3.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Vrml_Coordinate3,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Vrml_Coordinate3,Standard_Transient)
Vrml_Coordinate3::Vrml_Coordinate3(const Handle(TColgp_HArray1OfVec)& aPoint)
{
#include <Standard_Type.hxx>
#include <TColgp_HArray1OfVec.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_OStream.hxx>
class Vrml_Coordinate3;
-DEFINE_STANDARD_HANDLE(Vrml_Coordinate3, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Vrml_Coordinate3, Standard_Transient)
//! defines a Coordinate3 node of VRML specifying
//! properties of geometry and its appearance.
//! IndexedLineSet, or PointSet node. This node does not produce a visible result
//! during rendering; it simply replaces the current coordinates in the rendering
//! state for subsequent nodes to use.
-class Vrml_Coordinate3 : public MMgt_TShared
+class Vrml_Coordinate3 : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Vrml_Coordinate3,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Vrml_Coordinate3,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <Vrml_IndexedFaceSet.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Vrml_IndexedFaceSet,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Vrml_IndexedFaceSet,Standard_Transient)
Vrml_IndexedFaceSet::Vrml_IndexedFaceSet(const Handle(TColStd_HArray1OfInteger)& aCoordIndex,
const Handle(TColStd_HArray1OfInteger)& aMaterialIndex,
#include <Standard_Type.hxx>
#include <TColStd_HArray1OfInteger.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_OStream.hxx>
class Vrml_IndexedFaceSet;
-DEFINE_STANDARD_HANDLE(Vrml_IndexedFaceSet, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Vrml_IndexedFaceSet, Standard_Transient)
//! defines a IndexedFaceSet node of VRML specifying geometry shapes.
//! This node represents a 3D shape formed by constructing faces (polygons) from
//! vertices located at the current coordinates. IndexedFaceSet uses the indices
//! in its coordIndex to define polygonal faces. An index of -1 separates faces
//! (so a -1 at the end of the list is optional).
-class Vrml_IndexedFaceSet : public MMgt_TShared
+class Vrml_IndexedFaceSet : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Vrml_IndexedFaceSet,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Vrml_IndexedFaceSet,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <Vrml_IndexedLineSet.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Vrml_IndexedLineSet,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Vrml_IndexedLineSet,Standard_Transient)
Vrml_IndexedLineSet::Vrml_IndexedLineSet(const Handle(TColStd_HArray1OfInteger)& aCoordIndex,
const Handle(TColStd_HArray1OfInteger)& aMaterialIndex,
#include <Standard_Type.hxx>
#include <TColStd_HArray1OfInteger.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_OStream.hxx>
class Vrml_IndexedLineSet;
-DEFINE_STANDARD_HANDLE(Vrml_IndexedLineSet, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Vrml_IndexedLineSet, Standard_Transient)
//! defines a IndexedLineSet node of VRML specifying geometry shapes.
//! This node represents a 3D shape formed by constructing polylines from vertices
//! to OVERALL. The DEFAULT normal binding is equal to PER_VERTEX_INDEXED;
//! if insufficient normals exist in the state, the lines will be drawn unlit. The same
//! rules for texture coordinate generation as IndexedFaceSet are used.
-class Vrml_IndexedLineSet : public MMgt_TShared
+class Vrml_IndexedLineSet : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Vrml_IndexedLineSet,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Vrml_IndexedLineSet,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <Vrml_LOD.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Vrml_LOD,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Vrml_LOD,Standard_Transient)
Vrml_LOD::Vrml_LOD()
{
#include <TColStd_HArray1OfReal.hxx>
#include <gp_Vec.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_OStream.hxx>
class gp_Vec;
class Vrml_LOD;
-DEFINE_STANDARD_HANDLE(Vrml_LOD, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Vrml_LOD, Standard_Transient)
//! defines a LOD (level of detailization) node of VRML specifying properties
//! of geometry and its appearance.
//! are specified, the extra children w ll be ignored.
//! Each value in the ranges array should be greater than the previous
//! value, otherwise results are undefined.
-class Vrml_LOD : public MMgt_TShared
+class Vrml_LOD : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Vrml_LOD,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Vrml_LOD,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <Vrml_Material.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Vrml_Material,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Vrml_Material,Standard_Transient)
Vrml_Material::Vrml_Material(const Handle(Quantity_HArray1OfColor)& aAmbientColor,
const Handle(Quantity_HArray1OfColor)& aDiffuseColor,
#include <Quantity_HArray1OfColor.hxx>
#include <TColStd_HArray1OfReal.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_OStream.hxx>
class Vrml_Material;
-DEFINE_STANDARD_HANDLE(Vrml_Material, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Vrml_Material, Standard_Transient)
//! defines a Material node of VRML specifying properties of geometry
//! and its appearance.
//! Material sets several components of the current material during traversal. Different shapes
//! interpret materials with multiple values differently. To bind materials to shapes, use a
//! MaterialBinding node.
-class Vrml_Material : public MMgt_TShared
+class Vrml_Material : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Vrml_Material,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Vrml_Material,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <Vrml_Normal.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Vrml_Normal,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Vrml_Normal,Standard_Transient)
Vrml_Normal::Vrml_Normal(const Handle(TColgp_HArray1OfVec)& aVector)
{
#include <Standard_Type.hxx>
#include <TColgp_HArray1OfVec.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_OStream.hxx>
class Vrml_Normal;
-DEFINE_STANDARD_HANDLE(Vrml_Normal, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Vrml_Normal, Standard_Transient)
//! defines a Normal node of VRML specifying properties of geometry
//! and its appearance.
//! node does not produce a visible result during rendering; it simply replaces the current
//! normals in the rendering state for subsequent nodes to use. This node contains one
//! multiple-valued field that contains the normal vectors.
-class Vrml_Normal : public MMgt_TShared
+class Vrml_Normal : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Vrml_Normal,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Vrml_Normal,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <Vrml_SFImage.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Vrml_SFImage,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Vrml_SFImage,Standard_Transient)
Vrml_SFImage::Vrml_SFImage()
{
#include <Vrml_SFImageNumber.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class Vrml_SFImage;
-DEFINE_STANDARD_HANDLE(Vrml_SFImage, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Vrml_SFImage, Standard_Transient)
//! defines SFImage type of VRML field types.
-class Vrml_SFImage : public MMgt_TShared
+class Vrml_SFImage : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Vrml_SFImage,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Vrml_SFImage,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <Vrml_TextureCoordinate2.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Vrml_TextureCoordinate2,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(Vrml_TextureCoordinate2,Standard_Transient)
Vrml_TextureCoordinate2::Vrml_TextureCoordinate2()
{
#include <Standard_Type.hxx>
#include <TColgp_HArray1OfVec2d.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_OStream.hxx>
class Vrml_TextureCoordinate2;
-DEFINE_STANDARD_HANDLE(Vrml_TextureCoordinate2, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(Vrml_TextureCoordinate2, Standard_Transient)
//! defines a TextureCoordinate2 node of VRML specifying properties of geometry
//! and its appearance.
//! by vertical coordinate, T.
//! By default :
//! myPoint (0 0)
-class Vrml_TextureCoordinate2 : public MMgt_TShared
+class Vrml_TextureCoordinate2 : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(Vrml_TextureCoordinate2,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(Vrml_TextureCoordinate2,Standard_Transient)
protected:
#include <VrmlConverter_PointAspect.hxx>
#include <VrmlConverter_ShadingAspect.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(VrmlConverter_Drawer,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(VrmlConverter_Drawer,Standard_Transient)
VrmlConverter_Drawer::VrmlConverter_Drawer():
myNbPoints(17),
#include <Standard_Boolean.hxx>
#include <Aspect_TypeOfDeflection.hxx>
#include <Standard_Real.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class VrmlConverter_IsoAspect;
class VrmlConverter_LineAspect;
class VrmlConverter_ShadingAspect;
class VrmlConverter_Drawer;
-DEFINE_STANDARD_HANDLE(VrmlConverter_Drawer, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(VrmlConverter_Drawer, Standard_Transient)
//! qualifies the aspect properties for
//! the VRML conversation of a specific kind of object.
//! This includes for example color, maximal chordial deviation, etc...
-class VrmlConverter_Drawer : public MMgt_TShared
+class VrmlConverter_Drawer : public Standard_Transient
{
public:
//! sets LineAspect for the seen lines.
Standard_EXPORT void SetSeenLineAspect (const Handle(VrmlConverter_LineAspect)& anAspect);
- DEFINE_STANDARD_RTTIEXT(VrmlConverter_Drawer,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(VrmlConverter_Drawer,Standard_Transient)
private:
#include <Vrml_Material.hxx>
#include <VrmlConverter_LineAspect.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(VrmlConverter_LineAspect,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(VrmlConverter_LineAspect,Standard_Transient)
VrmlConverter_LineAspect::VrmlConverter_LineAspect()
{
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class Vrml_Material;
class VrmlConverter_LineAspect;
-DEFINE_STANDARD_HANDLE(VrmlConverter_LineAspect, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(VrmlConverter_LineAspect, Standard_Transient)
//! qualifies the aspect properties for
//! the VRML conversation of a Curve and a DeflectionCurve .
-class VrmlConverter_LineAspect : public MMgt_TShared
+class VrmlConverter_LineAspect : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(VrmlConverter_LineAspect,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(VrmlConverter_LineAspect,Standard_Transient)
protected:
#include <Vrml_Material.hxx>
#include <VrmlConverter_PointAspect.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(VrmlConverter_PointAspect,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(VrmlConverter_PointAspect,Standard_Transient)
VrmlConverter_PointAspect::VrmlConverter_PointAspect()
{
#include <Standard_Type.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class Vrml_Material;
class VrmlConverter_PointAspect;
-DEFINE_STANDARD_HANDLE(VrmlConverter_PointAspect, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(VrmlConverter_PointAspect, Standard_Transient)
//! qualifies the aspect properties for
//! the VRML conversation of a Point Set.
-class VrmlConverter_PointAspect : public MMgt_TShared
+class VrmlConverter_PointAspect : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(VrmlConverter_PointAspect,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(VrmlConverter_PointAspect,Standard_Transient)
protected:
#include <Vrml_TransformSeparator.hxx>
#include <VrmlConverter_Projector.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(VrmlConverter_Projector,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(VrmlConverter_Projector,Standard_Transient)
VrmlConverter_Projector::VrmlConverter_Projector (const TopTools_Array1OfShape& Shapes,
const Standard_Real Focus,
#include <VrmlConverter_TypeOfCamera.hxx>
#include <VrmlConverter_TypeOfLight.hxx>
#include <Vrml_MatrixTransform.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TopTools_Array1OfShape.hxx>
#include <Standard_OStream.hxx>
class HLRAlgo_Projector;
class VrmlConverter_Projector;
-DEFINE_STANDARD_HANDLE(VrmlConverter_Projector, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(VrmlConverter_Projector, Standard_Transient)
//! defines projector and calculates properties of cameras and lights from Vrml
//! and MatrixTransform ) to display all scene shapes with arbitrary locations
//! for requested the Projection Vector, High Point Direction and the Focus
//! and adds them ( method Add ) to anOSream.
-class VrmlConverter_Projector : public MMgt_TShared
+class VrmlConverter_Projector : public Standard_Transient
{
public:
Standard_EXPORT HLRAlgo_Projector Projector() const;
- DEFINE_STANDARD_RTTIEXT(VrmlConverter_Projector,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(VrmlConverter_Projector,Standard_Transient)
private:
#include <Vrml_ShapeHints.hxx>
#include <VrmlConverter_ShadingAspect.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(VrmlConverter_ShadingAspect,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(VrmlConverter_ShadingAspect,Standard_Transient)
VrmlConverter_ShadingAspect::VrmlConverter_ShadingAspect()
{
#include <Vrml_ShapeHints.hxx>
#include <Standard_Boolean.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class Vrml_Material;
class Vrml_ShapeHints;
class VrmlConverter_ShadingAspect;
-DEFINE_STANDARD_HANDLE(VrmlConverter_ShadingAspect, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(VrmlConverter_ShadingAspect, Standard_Transient)
//! qualifies the aspect properties for
//! the VRML conversation of ShadedShape .
-class VrmlConverter_ShadingAspect : public MMgt_TShared
+class VrmlConverter_ShadingAspect : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(VrmlConverter_ShadingAspect,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(VrmlConverter_ShadingAspect,Standard_Transient)
protected:
#include <XSAlgo_ToolContainer.hxx>
#include <TopExp_Explorer.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(XSAlgo_AlgoContainer,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(XSAlgo_AlgoContainer,Standard_Transient)
//=======================================================================
//function : XSAlgo_AlgoContainer
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Real.hxx>
#include <Standard_CString.hxx>
#include <Standard_Boolean.hxx>
class XSAlgo_AlgoContainer;
-DEFINE_STANDARD_HANDLE(XSAlgo_AlgoContainer, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(XSAlgo_AlgoContainer, Standard_Transient)
-class XSAlgo_AlgoContainer : public MMgt_TShared
+class XSAlgo_AlgoContainer : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(XSAlgo_AlgoContainer,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(XSAlgo_AlgoContainer,Standard_Transient)
protected:
#include <Standard_Type.hxx>
#include <XSAlgo_ToolContainer.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(XSAlgo_ToolContainer,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(XSAlgo_ToolContainer,Standard_Transient)
//=======================================================================
//function : XSAlgo_ToolContainer
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
class XSAlgo_ToolContainer;
-DEFINE_STANDARD_HANDLE(XSAlgo_ToolContainer, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(XSAlgo_ToolContainer, Standard_Transient)
//! Returns tools used by AlgoContainer
-class XSAlgo_ToolContainer : public MMgt_TShared
+class XSAlgo_ToolContainer : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(XSAlgo_ToolContainer,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(XSAlgo_ToolContainer,Standard_Transient)
protected:
#include <XSControl_TransferReader.hxx>
#include <XSControl_WorkSession.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(XSControl_Controller,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(XSControl_Controller,Standard_Transient)
// ParamEditor
// Transferts
#include <TColStd_HSequenceOfHAsciiString.hxx>
#include <TColStd_SequenceOfInteger.hxx>
#include <Interface_HArray1OfHAsciiString.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <NCollection_Vector.hxx>
#include <IFSelect_ReturnStatus.hxx>
#include <Standard_Transient.hxx>
class XSControl_Controller;
-DEFINE_STANDARD_HANDLE(XSControl_Controller, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(XSControl_Controller, Standard_Transient)
//! This class allows a general X-STEP engine to run generic
//! functions on any interface norm, in the same way. It includes
//!
//! It does not manage the produced data, but the Actors make the
//! link between the norm and the application
-class XSControl_Controller : public MMgt_TShared
+class XSControl_Controller : public Standard_Transient
{
public:
const NCollection_DataMap<TCollection_AsciiString, Handle(Standard_Transient)> & AdaptorSession() const
{ return myAdaptorSession; }
- DEFINE_STANDARD_RTTIEXT(XSControl_Controller,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(XSControl_Controller,Standard_Transient)
protected:
#include <XSControl_Utils.hxx>
#include <stdio.h>
-IMPLEMENT_STANDARD_RTTIEXT(XSControl_TransferReader,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(XSControl_TransferReader,Standard_Transient)
//=======================================================================
//function : SetController
#include <TCollection_AsciiString.hxx>
#include <TColStd_DataMapOfIntegerTransient.hxx>
#include <TopTools_HSequenceOfShape.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <TColStd_HSequenceOfTransient.hxx>
#include <Interface_CheckStatus.hxx>
class XSControl_Controller;
class XSControl_TransferReader;
-DEFINE_STANDARD_HANDLE(XSControl_TransferReader, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(XSControl_TransferReader, Standard_Transient)
//! A TransferReader performs, manages, handles results of,
//! transfers done when reading a file (i.e. from entities of an
//!
//! Some more direct access are given for results which are
//! Transient or Shapes
-class XSControl_TransferReader : public MMgt_TShared
+class XSControl_TransferReader : public Standard_Transient
{
public:
//! entities which are in <list> (filter)
Standard_EXPORT static void PrintStatsOnList (const Handle(Transfer_TransientProcess)& theTP, const Handle(TColStd_HSequenceOfTransient)& theList, const Standard_Integer theWhat, const Standard_Integer theMode = 0);
- DEFINE_STANDARD_RTTIEXT(XSControl_TransferReader,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(XSControl_TransferReader,Standard_Transient)
private:
#include <XSControl_TransferWriter.hxx>
#include <XSControl_Utils.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(XSControl_TransferWriter,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(XSControl_TransferWriter,Standard_Transient)
//=======================================================================
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <IFSelect_ReturnStatus.hxx>
#include <Transfer_FinderProcess.hxx>
class XSControl_Controller;
class XSControl_TransferWriter;
-DEFINE_STANDARD_HANDLE(XSControl_TransferWriter, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(XSControl_TransferWriter, Standard_Transient)
//! TransferWriter gives help to control transfer to write a file
//! after having converted data from Cascade/Imagine
//! It works with a Controller (which itself can work with an
//! Actor to Write) and a FinderProcess. It records results and
//! checks
-class XSControl_TransferWriter : public MMgt_TShared
+class XSControl_TransferWriter : public Standard_Transient
{
public:
//! instead of keeping the original Mapper, whenever known
Standard_EXPORT Interface_CheckIterator ResultCheckList (const Handle(Interface_InterfaceModel)& theModel) const;
- DEFINE_STANDARD_RTTIEXT(XSControl_TransferWriter,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(XSControl_TransferWriter,Standard_Transient)
private:
#include <TopoDS_Shape.hxx>
#include <XSControl_Vars.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(XSControl_Vars,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(XSControl_Vars,Standard_Transient)
XSControl_Vars::XSControl_Vars() { }
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Transient.hxx>
class XSControl_Vars;
-DEFINE_STANDARD_HANDLE(XSControl_Vars, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(XSControl_Vars, Standard_Transient)
//! Defines a receptacle for externally defined variables, each
//! one has a name
//! This class provides a common form for this. It also provides
//! a default implementation (locally recorded variables in a
//! dictionary), but which is aimed to be redefined
-class XSControl_Vars : public MMgt_TShared
+class XSControl_Vars : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(XSControl_Vars,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(XSControl_Vars,Standard_Transient)
protected:
#include <XmlMDF_ADriver.hxx>
#include <XmlObjMgt_Persistent.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(XmlMDF_ADriver,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(XmlMDF_ADriver,Standard_Transient)
//=======================================================================
//function : XmlMDF_ADriver
#include <Standard_Type.hxx>
#include <TCollection_AsciiString.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_CString.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Type.hxx>
class XmlMDF_ADriver;
-DEFINE_STANDARD_HANDLE(XmlMDF_ADriver, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(XmlMDF_ADriver, Standard_Transient)
//! Attribute Storage/Retrieval Driver.
-class XmlMDF_ADriver : public MMgt_TShared
+class XmlMDF_ADriver : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(XmlMDF_ADriver,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(XmlMDF_ADriver,Standard_Transient)
protected:
#include <XmlMDF_ADriver.hxx>
#include <XmlMDF_ADriverTable.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(XmlMDF_ADriverTable,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(XmlMDF_ADriverTable,Standard_Transient)
//=======================================================================
//function : MDF_ADriverTable
#include <Standard_Type.hxx>
#include <XmlMDF_TypeADriverMap.hxx>
-#include <MMgt_TShared.hxx>
+#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Type.hxx>
class XmlMDF_ADriver;
class XmlMDF_ADriverTable;
-DEFINE_STANDARD_HANDLE(XmlMDF_ADriverTable, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(XmlMDF_ADriverTable, Standard_Transient)
//! A driver table is an object building links between
//! object types and object drivers. In the
//! translation process, a driver table is asked to
//! give a translation driver for each current object
//! to be translated.
-class XmlMDF_ADriverTable : public MMgt_TShared
+class XmlMDF_ADriverTable : public Standard_Transient
{
public:
- DEFINE_STANDARD_RTTIEXT(XmlMDF_ADriverTable,MMgt_TShared)
+ DEFINE_STANDARD_RTTIEXT(XmlMDF_ADriverTable,Standard_Transient)
protected:
projects / occt-copy.git / commitdiff