Integration of OCCT 6.5.0 from SVN

src/StepGeom/StepGeom.cdl

@@ -0,0 +1,237 @@
+-- File:        StepGeom.cdl
+-- Created:     Fri Dec  1 11:11:09 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+
+package StepGeom 
+
+    ---Purpose : AP214 CC1 , Revision 4  for Geom (Part42, geometric)
+    --           Upgrading from Revision 2 to Revision 4 : 26 Mar 1997
+
+uses
+
+
+	TCollection, TColStd, StepData, Interface, MMgt,
+	StepBasic, StepRepr
+
+is
+
+
+enumeration BSplineCurveForm is     -- reordered from Rev2 to Rev4
+
+	bscfPolylineForm,
+	bscfCircularArc,
+	bscfEllipticArc,
+	bscfParabolicArc,
+	bscfHyperbolicArc,
+	bscfUnspecified
+end;
+
+enumeration BSplineSurfaceForm is   -- reordered from Rev2 to Rev4
+
+	bssfPlaneSurf,
+	bssfCylindricalSurf,
+	bssfConicalSurf,
+	bssfSphericalSurf,
+	bssfToroidalSurf,
+	bssfSurfOfRevolution,
+	bssfRuledSurf,
+	bssfGeneralisedCone,
+	bssfQuadricSurf,
+	bssfSurfOfLinearExtrusion,
+	bssfUnspecified
+end;
+
+enumeration KnotType is     -- reordered from Rev2 to Rev4
+
+	ktUniformKnots,
+	ktUnspecified,
+	ktQuasiUniformKnots,
+	ktPiecewiseBezierKnots
+end;
+
+enumeration PreferredSurfaceCurveRepresentation is   -- reordered Rev2 to Rev4
+
+	pscrCurve3d,
+	pscrPcurveS1,
+	pscrPcurveS2
+end;
+
+-- Removed from Rev2 to Rev4 :enumeration TextPath
+
+enumeration TransitionCode is   -- reordered from Rev2 to Rev4
+
+	tcDiscontinuous,
+	tcContinuous,
+	tcContSameGradient,
+	tcContSameGradientSameCurvature
+end;
+
+enumeration TrimmingPreference is   -- reordered from Rev2 to Rev4
+
+	tpCartesian,
+	tpParameter,
+	tpUnspecified
+end;
+
+class Axis2Placement;		-- Select Type for
+
+	-- Axis2Placement2d
+	-- Axis2Placement3d
+
+
+class CurveOnSurface;		-- Select Type for
+
+	-- Pcurve
+	-- SurfaceCurve
+	-- CompositeCurveOnSurface
+
+class PcurveOrSurface;		-- Select Type for
+
+	-- Pcurve
+	-- Surface
+
+
+class TrimmingSelect;		-- Select Type for
+
+	-- CartesianPoint
+	-- ParameterValue i.e. Real (TrimmingMember)
+
+class TrimmingMember;
+
+class VectorOrDirection;		-- Select Type for
+
+	-- Vector
+	-- Direction
+
+
+--class Protocol;
+
+
+class CompositeCurveSegment;
+	class ReparametrisedCompositeCurveSegment;
+--class RepresentationContext;
+	class GeometricRepresentationContext;
+	class GeometricRepresentationContextAndGlobalUnitAssignedContext;
+    	-- Hand Made by FMA :
+	class GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx;     
+    	-- Hand Made by FMA :
+	class GeometricRepresentationContextAndParametricRepresentationContext;
+--class RepresentationItem;
+	class GeometricRepresentationItem;
+		class CartesianTransformationOperator;
+			class CartesianTransformationOperator2d;
+			class CartesianTransformationOperator3d;
+		class Curve;
+			class BoundedCurve;
+				class BSplineCurve;
+					class BSplineCurveWithKnots;
+					class BezierCurve;
+					class QuasiUniformCurve;
+					class RationalBSplineCurve;
+					class UniformCurve;
+					class UniformCurveAndRationalBSplineCurve;
+					class BSplineCurveWithKnotsAndRationalBSplineCurve;
+					class QuasiUniformCurveAndRationalBSplineCurve;
+					class BezierCurveAndRationalBSplineCurve;
+				class CompositeCurve;
+					class CompositeCurveOnSurface;
+						class BoundaryCurve;
+							class OuterBoundaryCurve;
+				class Polyline;
+				class TrimmedCurve;
+			class Conic;
+				class Circle;
+				class Ellipse;
+				class Hyperbola;
+				class Parabola;
+			class CurveReplica;
+			class Line;
+			class OffsetCurve3d;
+			class Pcurve;
+			class SurfaceCurve;
+				class IntersectionCurve;
+				class SeamCurve;
+			    class SurfaceCurveAndBoundedCurve;
+		class Direction;
+		class Placement;
+			class Axis1Placement;
+			class Axis2Placement2d;
+			class Axis2Placement3d;
+--V		class PlanarExtent;
+--V			class PlanarBox;
+		class Point;
+			class CartesianPoint;
+			class DegeneratePcurve;
+				class EvaluatedDegeneratePcurve;
+			class PointOnCurve;
+			class PointOnSurface;
+			class PointReplica;
+		class Surface;
+			class BoundedSurface;
+				class BSplineSurface;
+					class BSplineSurfaceWithKnots;
+					class BezierSurface;
+					class QuasiUniformSurface;
+					class RationalBSplineSurface;
+					class UniformSurface;
+					class BSplineSurfaceWithKnotsAndRationalBSplineSurface;
+					class UniformSurfaceAndRationalBSplineSurface;
+					class QuasiUniformSurfaceAndRationalBSplineSurface;
+					class BezierSurfaceAndRationalBSplineSurface;
+				class CurveBoundedSurface;
+				class RectangularCompositeSurface;
+				class RectangularTrimmedSurface;
+			class ElementarySurface;
+				class ConicalSurface;
+				class CylindricalSurface;
+				class Plane;
+				class SphericalSurface;
+				class ToroidalSurface;
+					class DegenerateToroidalSurface;
+			class OffsetSurface;
+			class SurfaceReplica;
+			class SweptSurface;
+				class SurfaceOfLinearExtrusion;
+				class SurfaceOfRevolution;
+			class OrientedSurface; --  Added from AP214 DIS to IS 4.01.2002
+		class Vector;
+class SurfacePatch;
+class SurfaceBoundary;
+
+
+class Array1OfCurve instantiates Array1 from TCollection (Curve);
+class HArray1OfCurve instantiates HArray1 from TCollection (Curve,Array1OfCurve from StepGeom);
+
+class Array1OfCartesianPoint instantiates Array1 from TCollection (CartesianPoint);
+class HArray1OfCartesianPoint instantiates HArray1 from TCollection (CartesianPoint,Array1OfCartesianPoint from StepGeom);
+
+class Array2OfCartesianPoint instantiates Array2 from TCollection (CartesianPoint);
+class HArray2OfCartesianPoint instantiates HArray2 from TCollection (CartesianPoint,Array2OfCartesianPoint from StepGeom);
+
+class Array1OfCompositeCurveSegment instantiates Array1 from TCollection (CompositeCurveSegment);
+class HArray1OfCompositeCurveSegment instantiates HArray1 from TCollection (CompositeCurveSegment,Array1OfCompositeCurveSegment from StepGeom);
+
+class Array1OfBoundaryCurve instantiates Array1 from TCollection (BoundaryCurve);
+class HArray1OfBoundaryCurve instantiates HArray1 from TCollection (BoundaryCurve,Array1OfBoundaryCurve from StepGeom);
+
+class Array2OfSurfacePatch instantiates Array2 from TCollection (SurfacePatch);
+class HArray2OfSurfacePatch instantiates HArray2 from TCollection (SurfacePatch,Array2OfSurfacePatch from StepGeom);
+
+class Array1OfSurfaceBoundary instantiates Array1 from TCollection (SurfaceBoundary);
+class HArray1OfSurfaceBoundary instantiates HArray1 from TCollection (SurfaceBoundary,Array1OfSurfaceBoundary from StepGeom);
+
+class Array1OfPcurveOrSurface instantiates Array1 from TCollection (PcurveOrSurface);
+class HArray1OfPcurveOrSurface instantiates HArray1 from TCollection (PcurveOrSurface,Array1OfPcurveOrSurface from StepGeom);
+
+class Array1OfTrimmingSelect instantiates Array1 from TCollection (TrimmingSelect);
+class HArray1OfTrimmingSelect instantiates HArray1 from TCollection (TrimmingSelect,Array1OfTrimmingSelect from StepGeom);
+
+--	Protocol returns Protocol from StepGeom;
+	---Purpose : creates a Protocol
+
+end StepGeom;
+

src/StepGeom/StepGeom_Axis1Placement.cdl

@@ -0,0 +1,45 @@
+-- File:        Axis1Placement.cdl
+-- Created:     Fri Dec  1 11:11:14 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class Axis1Placement from StepGeom 
+
+inherits Placement from StepGeom 
+
+uses
+
+	Direction from StepGeom, 
+	Boolean from Standard, 
+	HAsciiString from TCollection, 
+	CartesianPoint from StepGeom
+is
+
+	Create returns mutable Axis1Placement;
+	---Purpose: Returns a Axis1Placement
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aLocation : mutable CartesianPoint from StepGeom) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aLocation : mutable CartesianPoint from StepGeom;
+	      hasAaxis : Boolean from Standard;
+	      aAxis : mutable Direction from StepGeom) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetAxis(me : mutable; aAxis : mutable Direction);
+	UnSetAxis (me:mutable);
+	Axis (me) returns mutable Direction;
+	HasAxis (me) returns Boolean;
+
+fields
+
+	axis : Direction from StepGeom;   -- OPTIONAL can be NULL
+	hasAxis : Boolean from Standard;
+
+end Axis1Placement;

src/StepGeom/StepGeom_Axis1Placement.cxx

@@ -0,0 +1,48 @@
+#include <StepGeom_Axis1Placement.ixx>
+
+
+StepGeom_Axis1Placement::StepGeom_Axis1Placement ()  {}
+
+void StepGeom_Axis1Placement::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Handle(StepGeom_CartesianPoint)& aLocation)
+{
+
+	StepGeom_Placement::Init(aName, aLocation);
+}
+
+void StepGeom_Axis1Placement::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Handle(StepGeom_CartesianPoint)& aLocation,
+	const Standard_Boolean hasAaxis,
+	const Handle(StepGeom_Direction)& aAxis)
+{
+	// --- classe own fields ---
+	hasAxis = hasAaxis;
+	axis = aAxis;
+	// --- classe inherited fields ---
+	StepGeom_Placement::Init(aName, aLocation);
+}
+
+
+void StepGeom_Axis1Placement::SetAxis(const Handle(StepGeom_Direction)& aAxis)
+{
+	axis = aAxis;
+	hasAxis = Standard_True;
+}
+
+void StepGeom_Axis1Placement::UnSetAxis()
+{
+	hasAxis = Standard_False;
+	axis.Nullify();
+}
+
+Handle(StepGeom_Direction) StepGeom_Axis1Placement::Axis() const
+{
+	return axis;
+}
+
+Standard_Boolean StepGeom_Axis1Placement::HasAxis() const
+{
+	return hasAxis;
+}

src/StepGeom/StepGeom_Axis2Placement.cdl

@@ -0,0 +1,36 @@
+-- File:        Axis2Placement.cdl
+-- Created:     Fri Dec  1 11:11:10 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+class Axis2Placement from StepGeom inherits SelectType from StepData
+
+	-- <Axis2Placement> is an EXPRESS Select Type construct translation.
+	-- it gathers : Axis2Placement2d, Axis2Placement3d
+
+uses
+
+	Axis2Placement2d,
+	Axis2Placement3d
+is
+
+	Create returns Axis2Placement;
+	---Purpose : Returns a Axis2Placement SelectType
+
+	CaseNum (me; ent : Transient) returns Integer;
+	---Purpose: Recognizes a Axis2Placement Kind Entity that is :
+	--        1 -> Axis2Placement2d
+	--        2 -> Axis2Placement3d
+	--        0 else
+
+	Axis2Placement2d (me) returns any Axis2Placement2d;
+	---Purpose : returns Value as a Axis2Placement2d (Null if another type)
+
+	Axis2Placement3d (me) returns any Axis2Placement3d;
+	---Purpose : returns Value as a Axis2Placement3d (Null if another type)
+
+
+end Axis2Placement;
+

src/StepGeom/StepGeom_Axis2Placement.cxx

@@ -0,0 +1,23 @@
+
+#include <StepGeom_Axis2Placement.ixx>
+#include <Interface_Macros.hxx>
+
+StepGeom_Axis2Placement::StepGeom_Axis2Placement () {  }
+
+Standard_Integer StepGeom_Axis2Placement::CaseNum(const Handle(Standard_Transient)& ent) const
+{
+	if (ent.IsNull()) return 0;
+	if (ent->IsKind(STANDARD_TYPE(StepGeom_Axis2Placement2d))) return 1;
+	if (ent->IsKind(STANDARD_TYPE(StepGeom_Axis2Placement3d))) return 2;
+	return 0;
+}
+
+Handle(StepGeom_Axis2Placement2d) StepGeom_Axis2Placement::Axis2Placement2d () const
+{
+	return GetCasted(StepGeom_Axis2Placement2d,Value());
+}
+
+Handle(StepGeom_Axis2Placement3d) StepGeom_Axis2Placement::Axis2Placement3d () const
+{
+	return GetCasted(StepGeom_Axis2Placement3d,Value());
+}

src/StepGeom/StepGeom_Axis2Placement2d.cdl

@@ -0,0 +1,45 @@
+-- File:        Axis2Placement2d.cdl
+-- Created:     Fri Dec  1 11:11:14 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class Axis2Placement2d from StepGeom 
+
+inherits Placement from StepGeom 
+
+uses
+
+	Direction from StepGeom, 
+	Boolean from Standard, 
+	HAsciiString from TCollection, 
+	CartesianPoint from StepGeom
+is
+
+	Create returns mutable Axis2Placement2d;
+	---Purpose: Returns a Axis2Placement2d
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aLocation : mutable CartesianPoint from StepGeom) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aLocation : mutable CartesianPoint from StepGeom;
+	      hasArefDirection : Boolean from Standard;
+	      aRefDirection : mutable Direction from StepGeom) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetRefDirection(me : mutable; aRefDirection : mutable Direction);
+	UnSetRefDirection (me:mutable);
+	RefDirection (me) returns mutable Direction;
+	HasRefDirection (me) returns Boolean;
+
+fields
+
+	refDirection : Direction from StepGeom;   -- OPTIONAL can be NULL
+	hasRefDirection : Boolean from Standard;
+
+end Axis2Placement2d;

src/StepGeom/StepGeom_Axis2Placement2d.cxx

@@ -0,0 +1,48 @@
+#include <StepGeom_Axis2Placement2d.ixx>
+
+
+StepGeom_Axis2Placement2d::StepGeom_Axis2Placement2d ()  {}
+
+void StepGeom_Axis2Placement2d::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Handle(StepGeom_CartesianPoint)& aLocation)
+{
+
+	StepGeom_Placement::Init(aName, aLocation);
+}
+
+void StepGeom_Axis2Placement2d::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Handle(StepGeom_CartesianPoint)& aLocation,
+	const Standard_Boolean hasArefDirection,
+	const Handle(StepGeom_Direction)& aRefDirection)
+{
+	// --- classe own fields ---
+	hasRefDirection = hasArefDirection;
+	refDirection = aRefDirection;
+	// --- classe inherited fields ---
+	StepGeom_Placement::Init(aName, aLocation);
+}
+
+
+void StepGeom_Axis2Placement2d::SetRefDirection(const Handle(StepGeom_Direction)& aRefDirection)
+{
+	refDirection = aRefDirection;
+	hasRefDirection = Standard_True;
+}
+
+void StepGeom_Axis2Placement2d::UnSetRefDirection()
+{
+	hasRefDirection = Standard_False;
+	refDirection.Nullify();
+}
+
+Handle(StepGeom_Direction) StepGeom_Axis2Placement2d::RefDirection() const
+{
+	return refDirection;
+}
+
+Standard_Boolean StepGeom_Axis2Placement2d::HasRefDirection() const
+{
+	return hasRefDirection;
+}

src/StepGeom/StepGeom_Axis2Placement3d.cdl

@@ -0,0 +1,53 @@
+-- File:        Axis2Placement3d.cdl
+-- Created:     Fri Dec  1 11:11:14 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class Axis2Placement3d from StepGeom 
+
+inherits Placement from StepGeom 
+
+uses
+
+	Direction from StepGeom, 
+	Boolean from Standard, 
+	HAsciiString from TCollection, 
+	CartesianPoint from StepGeom
+is
+
+	Create returns mutable Axis2Placement3d;
+	---Purpose: Returns a Axis2Placement3d
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aLocation : mutable CartesianPoint from StepGeom) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aLocation : mutable CartesianPoint from StepGeom;
+	      hasAaxis : Boolean from Standard;
+	      aAxis : mutable Direction from StepGeom;
+	      hasArefDirection : Boolean from Standard;
+	      aRefDirection : mutable Direction from StepGeom) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetAxis(me : mutable; aAxis : mutable Direction);
+	UnSetAxis (me:mutable);
+	Axis (me) returns mutable Direction;
+	HasAxis (me) returns Boolean;
+	SetRefDirection(me : mutable; aRefDirection : mutable Direction);
+	UnSetRefDirection (me:mutable);
+	RefDirection (me) returns mutable Direction;
+	HasRefDirection (me) returns Boolean;
+
+fields
+
+	axis : Direction from StepGeom;   -- OPTIONAL can be NULL
+	refDirection : Direction from StepGeom;   -- OPTIONAL can be NULL
+	hasAxis : Boolean from Standard;
+	hasRefDirection : Boolean from Standard;
+
+end Axis2Placement3d;

src/StepGeom/StepGeom_Axis2Placement3d.cxx

@@ -0,0 +1,74 @@
+#include <StepGeom_Axis2Placement3d.ixx>
+
+
+StepGeom_Axis2Placement3d::StepGeom_Axis2Placement3d ()  {}
+
+void StepGeom_Axis2Placement3d::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Handle(StepGeom_CartesianPoint)& aLocation)
+{
+
+	StepGeom_Placement::Init(aName, aLocation);
+}
+
+void StepGeom_Axis2Placement3d::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Handle(StepGeom_CartesianPoint)& aLocation,
+	const Standard_Boolean hasAaxis,
+	const Handle(StepGeom_Direction)& aAxis,
+	const Standard_Boolean hasArefDirection,
+	const Handle(StepGeom_Direction)& aRefDirection)
+{
+	// --- classe own fields ---
+	hasAxis = hasAaxis;
+	axis = aAxis;
+	hasRefDirection = hasArefDirection;
+	refDirection = aRefDirection;
+	// --- classe inherited fields ---
+	StepGeom_Placement::Init(aName, aLocation);
+}
+
+
+void StepGeom_Axis2Placement3d::SetAxis(const Handle(StepGeom_Direction)& aAxis)
+{
+	axis = aAxis;
+	hasAxis = Standard_True;
+}
+
+void StepGeom_Axis2Placement3d::UnSetAxis()
+{
+	hasAxis = Standard_False;
+	axis.Nullify();
+}
+
+Handle(StepGeom_Direction) StepGeom_Axis2Placement3d::Axis() const
+{
+	return axis;
+}
+
+Standard_Boolean StepGeom_Axis2Placement3d::HasAxis() const
+{
+	return hasAxis;
+}
+
+void StepGeom_Axis2Placement3d::SetRefDirection(const Handle(StepGeom_Direction)& aRefDirection)
+{
+	refDirection = aRefDirection;
+	hasRefDirection = Standard_True;
+}
+
+void StepGeom_Axis2Placement3d::UnSetRefDirection()
+{
+	hasRefDirection = Standard_False;
+	refDirection.Nullify();
+}
+
+Handle(StepGeom_Direction) StepGeom_Axis2Placement3d::RefDirection() const
+{
+	return refDirection;
+}
+
+Standard_Boolean StepGeom_Axis2Placement3d::HasRefDirection() const
+{
+	return hasRefDirection;
+}

src/StepGeom/StepGeom_BSplineCurve.cdl

@@ -0,0 +1,64 @@
+-- File:        BSplineCurve.cdl
+-- Created:     Fri Dec  1 11:11:14 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class BSplineCurve from StepGeom 
+
+inherits BoundedCurve from StepGeom 
+
+
+  -- N.B : EXPRESS Complexe SUBTYPE Declaration :
+
+  -- ANDOR ( ONEOF ( uniform_curve b_spline_curve_with_knots quasi_uniform_curve bezier_curve ) rational_b_spline_curve ) 
+
+uses
+
+	Integer from Standard, 
+	HArray1OfCartesianPoint from StepGeom, 
+	BSplineCurveForm from StepGeom, 
+	Logical from StepData, 
+	CartesianPoint from StepGeom, 
+	HAsciiString from TCollection
+is
+
+	Create returns mutable BSplineCurve;
+	---Purpose: Returns a BSplineCurve
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aDegree : Integer from Standard;
+	      aControlPointsList : mutable HArray1OfCartesianPoint from StepGeom;
+	      aCurveForm : BSplineCurveForm from StepGeom;
+	      aClosedCurve : Logical from StepData;
+	      aSelfIntersect : Logical from StepData) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetDegree(me : mutable; aDegree : Integer);
+	Degree (me) returns Integer;
+	SetControlPointsList(me : mutable; aControlPointsList : mutable HArray1OfCartesianPoint);
+	ControlPointsList (me) returns mutable HArray1OfCartesianPoint;
+	ControlPointsListValue (me; num : Integer) returns mutable CartesianPoint;
+	NbControlPointsList (me) returns Integer;
+	SetCurveForm(me : mutable; aCurveForm : BSplineCurveForm);
+	CurveForm (me) returns BSplineCurveForm;
+	SetClosedCurve(me : mutable; aClosedCurve : Logical);
+	ClosedCurve (me) returns Logical;
+	SetSelfIntersect(me : mutable; aSelfIntersect : Logical);
+	SelfIntersect (me) returns Logical;
+
+fields
+
+	degree : Integer from Standard;
+	controlPointsList : HArray1OfCartesianPoint from StepGeom;
+	curveForm : BSplineCurveForm from StepGeom; -- an Enumeration
+	closedCurve : Logical from StepData;
+	selfIntersect : Logical from StepData;
+
+end BSplineCurve;

src/StepGeom/StepGeom_BSplineCurve.cxx

@@ -0,0 +1,91 @@
+#include <StepGeom_BSplineCurve.ixx>
+
+
+StepGeom_BSplineCurve::StepGeom_BSplineCurve ()  {}
+
+void StepGeom_BSplineCurve::Init(
+	const Handle(TCollection_HAsciiString)& aName)
+{
+
+	StepRepr_RepresentationItem::Init(aName);
+}
+
+void StepGeom_BSplineCurve::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Standard_Integer aDegree,
+	const Handle(StepGeom_HArray1OfCartesianPoint)& aControlPointsList,
+	const StepGeom_BSplineCurveForm aCurveForm,
+	const StepData_Logical aClosedCurve,
+	const StepData_Logical aSelfIntersect)
+{
+	// --- classe own fields ---
+	degree = aDegree;
+	controlPointsList = aControlPointsList;
+	curveForm = aCurveForm;
+	closedCurve = aClosedCurve;
+	selfIntersect = aSelfIntersect;
+	// --- classe inherited fields ---
+	StepRepr_RepresentationItem::Init(aName);
+}
+
+
+void StepGeom_BSplineCurve::SetDegree(const Standard_Integer aDegree)
+{
+	degree = aDegree;
+}
+
+Standard_Integer StepGeom_BSplineCurve::Degree() const
+{
+	return degree;
+}
+
+void StepGeom_BSplineCurve::SetControlPointsList(const Handle(StepGeom_HArray1OfCartesianPoint)& aControlPointsList)
+{
+	controlPointsList = aControlPointsList;
+}
+
+Handle(StepGeom_HArray1OfCartesianPoint) StepGeom_BSplineCurve::ControlPointsList() const
+{
+	return controlPointsList;
+}
+
+Handle(StepGeom_CartesianPoint) StepGeom_BSplineCurve::ControlPointsListValue(const Standard_Integer num) const
+{
+	return controlPointsList->Value(num);
+}
+
+Standard_Integer StepGeom_BSplineCurve::NbControlPointsList () const
+{
+	if (controlPointsList.IsNull()) return 0;
+	return controlPointsList->Length();
+}
+
+void StepGeom_BSplineCurve::SetCurveForm(const StepGeom_BSplineCurveForm aCurveForm)
+{
+	curveForm = aCurveForm;
+}
+
+StepGeom_BSplineCurveForm StepGeom_BSplineCurve::CurveForm() const
+{
+	return curveForm;
+}
+
+void StepGeom_BSplineCurve::SetClosedCurve(const StepData_Logical aClosedCurve)
+{
+	closedCurve = aClosedCurve;
+}
+
+StepData_Logical StepGeom_BSplineCurve::ClosedCurve() const
+{
+	return closedCurve;
+}
+
+void StepGeom_BSplineCurve::SetSelfIntersect(const StepData_Logical aSelfIntersect)
+{
+	selfIntersect = aSelfIntersect;
+}
+
+StepData_Logical StepGeom_BSplineCurve::SelfIntersect() const
+{
+	return selfIntersect;
+}

src/StepGeom/StepGeom_BSplineCurveWithKnots.cdl

@@ -0,0 +1,66 @@
+-- File:        BSplineCurveWithKnots.cdl
+-- Created:     Fri Dec  1 11:11:14 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class BSplineCurveWithKnots from StepGeom 
+
+inherits BSplineCurve from StepGeom 
+
+uses
+
+	HArray1OfInteger from TColStd, 
+	HArray1OfReal from TColStd, 
+	KnotType from StepGeom, 
+	Integer from Standard, 
+	Real from Standard, 
+	HAsciiString from TCollection, 
+	HArray1OfCartesianPoint from StepGeom, 
+	BSplineCurveForm from StepGeom, 
+	Logical from StepData
+is
+
+	Create returns mutable BSplineCurveWithKnots;
+	---Purpose: Returns a BSplineCurveWithKnots
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aDegree : Integer from Standard;
+	      aControlPointsList : mutable HArray1OfCartesianPoint from StepGeom;
+	      aCurveForm : BSplineCurveForm from StepGeom;
+	      aClosedCurve : Logical from StepData;
+	      aSelfIntersect : Logical from StepData) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aDegree : Integer from Standard;
+	      aControlPointsList : mutable HArray1OfCartesianPoint from StepGeom;
+	      aCurveForm : BSplineCurveForm from StepGeom;
+	      aClosedCurve : Logical from StepData;
+	      aSelfIntersect : Logical from StepData;
+	      aKnotMultiplicities : mutable HArray1OfInteger from TColStd;
+	      aKnots : mutable HArray1OfReal from TColStd;
+	      aKnotSpec : KnotType from StepGeom) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetKnotMultiplicities(me : mutable; aKnotMultiplicities : mutable HArray1OfInteger);
+	KnotMultiplicities (me) returns mutable HArray1OfInteger;
+	KnotMultiplicitiesValue (me; num : Integer) returns Integer;
+	NbKnotMultiplicities (me) returns Integer;
+	SetKnots(me : mutable; aKnots : mutable HArray1OfReal);
+	Knots (me) returns mutable HArray1OfReal;
+	KnotsValue (me; num : Integer) returns Real;
+	NbKnots (me) returns Integer;
+	SetKnotSpec(me : mutable; aKnotSpec : KnotType);
+	KnotSpec (me) returns KnotType;
+
+fields
+
+	knotMultiplicities : HArray1OfInteger from TColStd;
+	knots : HArray1OfReal from TColStd;
+	knotSpec : KnotType from StepGeom; -- an Enumeration
+
+end BSplineCurveWithKnots;

src/StepGeom/StepGeom_BSplineCurveWithKnots.cxx

@@ -0,0 +1,86 @@
+#include <StepGeom_BSplineCurveWithKnots.ixx>
+
+
+StepGeom_BSplineCurveWithKnots::StepGeom_BSplineCurveWithKnots ()  {}
+
+void StepGeom_BSplineCurveWithKnots::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Standard_Integer aDegree,
+	const Handle(StepGeom_HArray1OfCartesianPoint)& aControlPointsList,
+	const StepGeom_BSplineCurveForm aCurveForm,
+	const StepData_Logical aClosedCurve,
+	const StepData_Logical aSelfIntersect)
+{
+
+	StepGeom_BSplineCurve::Init(aName, aDegree, aControlPointsList, aCurveForm, aClosedCurve, aSelfIntersect);
+}
+
+void StepGeom_BSplineCurveWithKnots::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Standard_Integer aDegree,
+	const Handle(StepGeom_HArray1OfCartesianPoint)& aControlPointsList,
+	const StepGeom_BSplineCurveForm aCurveForm,
+	const StepData_Logical aClosedCurve,
+	const StepData_Logical aSelfIntersect,
+	const Handle(TColStd_HArray1OfInteger)& aKnotMultiplicities,
+	const Handle(TColStd_HArray1OfReal)& aKnots,
+	const StepGeom_KnotType aKnotSpec)
+{
+	// --- classe own fields ---
+	knotMultiplicities = aKnotMultiplicities;
+	knots = aKnots;
+	knotSpec = aKnotSpec;
+	// --- classe inherited fields ---
+	StepGeom_BSplineCurve::Init(aName, aDegree, aControlPointsList, aCurveForm, aClosedCurve, aSelfIntersect);
+}
+
+
+void StepGeom_BSplineCurveWithKnots::SetKnotMultiplicities(const Handle(TColStd_HArray1OfInteger)& aKnotMultiplicities)
+{
+	knotMultiplicities = aKnotMultiplicities;
+}
+
+Handle(TColStd_HArray1OfInteger) StepGeom_BSplineCurveWithKnots::KnotMultiplicities() const
+{
+	return knotMultiplicities;
+}
+
+Standard_Integer StepGeom_BSplineCurveWithKnots::KnotMultiplicitiesValue(const Standard_Integer num) const
+{
+	return knotMultiplicities->Value(num);
+}
+
+Standard_Integer StepGeom_BSplineCurveWithKnots::NbKnotMultiplicities () const
+{
+	return knotMultiplicities->Length();
+}
+
+void StepGeom_BSplineCurveWithKnots::SetKnots(const Handle(TColStd_HArray1OfReal)& aKnots)
+{
+	knots = aKnots;
+}
+
+Handle(TColStd_HArray1OfReal) StepGeom_BSplineCurveWithKnots::Knots() const
+{
+	return knots;
+}
+
+Standard_Real StepGeom_BSplineCurveWithKnots::KnotsValue(const Standard_Integer num) const
+{
+	return knots->Value(num);
+}
+
+Standard_Integer StepGeom_BSplineCurveWithKnots::NbKnots () const
+{
+	return knots->Length();
+}
+
+void StepGeom_BSplineCurveWithKnots::SetKnotSpec(const StepGeom_KnotType aKnotSpec)
+{
+	knotSpec = aKnotSpec;
+}
+
+StepGeom_KnotType StepGeom_BSplineCurveWithKnots::KnotSpec() const
+{
+	return knotSpec;
+}

src/StepGeom/StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve.cdl

@@ -0,0 +1,95 @@
+-- File:        BSplineCurveWithKnotsAndRationalBSplineCurve.cdl
+-- Created:     Fri Dec  1 11:11:31 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class BSplineCurveWithKnotsAndRationalBSplineCurve from StepGeom 
+
+inherits BSplineCurve from StepGeom 
+
+
+	--- This classe is an implementation of EXPRESS
+	--  ANDOR Subtype Declaration.
+uses
+
+	BSplineCurveWithKnots from StepGeom, 
+	RationalBSplineCurve from StepGeom, 
+	HAsciiString from TCollection, 
+	Integer from Standard, 
+	HArray1OfCartesianPoint from StepGeom, 
+	BSplineCurveForm from StepGeom, 
+	Logical from StepData, 
+	HArray1OfInteger from TColStd, 
+	HArray1OfReal from TColStd, 
+	KnotType from StepGeom, 
+	Real from Standard
+is
+
+	Create returns mutable BSplineCurveWithKnotsAndRationalBSplineCurve;
+	---Purpose: Returns a BSplineCurveWithKnotsAndRationalBSplineCurve
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aDegree : Integer from Standard;
+	      aControlPointsList : mutable HArray1OfCartesianPoint from StepGeom;
+	      aCurveForm : BSplineCurveForm from StepGeom;
+	      aClosedCurve : Logical from StepData;
+	      aSelfIntersect : Logical from StepData) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aDegree : Integer from Standard;
+	      aControlPointsList : mutable HArray1OfCartesianPoint from StepGeom;
+	      aCurveForm : BSplineCurveForm from StepGeom;
+	      aClosedCurve : Logical from StepData;
+	      aSelfIntersect : Logical from StepData;
+	      aBSplineCurveWithKnots : mutable BSplineCurveWithKnots from StepGeom;
+	      aRationalBSplineCurve : mutable RationalBSplineCurve from StepGeom) is virtual;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aDegree : Integer from Standard;
+	      aControlPointsList : mutable HArray1OfCartesianPoint from StepGeom;
+	      aCurveForm : BSplineCurveForm from StepGeom;
+	      aClosedCurve : Logical from StepData;
+	      aSelfIntersect : Logical from StepData;
+	      aKnotMultiplicities : mutable HArray1OfInteger from TColStd;
+	      aKnots : mutable HArray1OfReal from TColStd;
+	      aKnotSpec : KnotType from StepGeom;
+	      aWeightsData : mutable HArray1OfReal from TColStd) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetBSplineCurveWithKnots(me : mutable; aBSplineCurveWithKnots : mutable BSplineCurveWithKnots);
+	BSplineCurveWithKnots (me) returns mutable BSplineCurveWithKnots;
+	SetRationalBSplineCurve(me : mutable; aRationalBSplineCurve : mutable RationalBSplineCurve);
+	RationalBSplineCurve (me) returns mutable RationalBSplineCurve;
+
+	-- Specific Methods for ANDOR Field Data Access --
+
+	SetKnotMultiplicities(me : mutable; aKnotMultiplicities : mutable HArray1OfInteger);
+	KnotMultiplicities (me) returns mutable HArray1OfInteger;
+	KnotMultiplicitiesValue (me; num : Integer) returns Integer;
+	NbKnotMultiplicities (me) returns Integer;
+	SetKnots(me : mutable; aKnots : mutable HArray1OfReal);
+	Knots (me) returns mutable HArray1OfReal;
+	KnotsValue (me; num : Integer) returns Real;
+	NbKnots (me) returns Integer;
+	SetKnotSpec(me : mutable; aKnotSpec : KnotType);
+	KnotSpec (me) returns KnotType;
+
+	-- Specific Methods for ANDOR Field Data Access --
+
+	SetWeightsData(me : mutable; aWeightsData : mutable HArray1OfReal);
+	WeightsData (me) returns mutable HArray1OfReal;
+	WeightsDataValue (me; num : Integer) returns Real;
+	NbWeightsData (me) returns Integer;
+
+fields
+
+	bSplineCurveWithKnots : BSplineCurveWithKnots from StepGeom;
+	rationalBSplineCurve : RationalBSplineCurve from StepGeom;
+
+end BSplineCurveWithKnotsAndRationalBSplineCurve;

src/StepGeom/StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve.cxx

@@ -0,0 +1,162 @@
+#include <StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve.ixx>
+
+#include <StepGeom_BSplineCurveWithKnots.hxx>
+
+#include <StepGeom_RationalBSplineCurve.hxx>
+
+
+StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve::StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve ()  {}
+
+void StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Standard_Integer aDegree,
+	const Handle(StepGeom_HArray1OfCartesianPoint)& aControlPointsList,
+	const StepGeom_BSplineCurveForm aCurveForm,
+	const StepData_Logical aClosedCurve,
+	const StepData_Logical aSelfIntersect)
+{
+
+	StepGeom_BSplineCurve::Init(aName, aDegree, aControlPointsList, aCurveForm, aClosedCurve, aSelfIntersect);
+}
+
+void StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Standard_Integer aDegree,
+	const Handle(StepGeom_HArray1OfCartesianPoint)& aControlPointsList,
+	const StepGeom_BSplineCurveForm aCurveForm,
+	const StepData_Logical aClosedCurve,
+	const StepData_Logical aSelfIntersect,
+	const Handle(StepGeom_BSplineCurveWithKnots)& aBSplineCurveWithKnots,
+	const Handle(StepGeom_RationalBSplineCurve)& aRationalBSplineCurve)
+{
+	// --- classe own fields ---
+	bSplineCurveWithKnots = aBSplineCurveWithKnots;
+	rationalBSplineCurve = aRationalBSplineCurve;
+	// --- classe inherited fields ---
+	StepGeom_BSplineCurve::Init(aName, aDegree, aControlPointsList, aCurveForm, aClosedCurve, aSelfIntersect);
+}
+
+
+void StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Standard_Integer aDegree,
+	const Handle(StepGeom_HArray1OfCartesianPoint)& aControlPointsList,
+	const StepGeom_BSplineCurveForm aCurveForm,
+	const StepData_Logical aClosedCurve,
+	const StepData_Logical aSelfIntersect,
+	const Handle(TColStd_HArray1OfInteger)& aKnotMultiplicities,
+	const Handle(TColStd_HArray1OfReal)& aKnots,
+	const StepGeom_KnotType aKnotSpec,
+	const Handle(TColStd_HArray1OfReal)& aWeightsData)
+{
+	// --- classe inherited fields ---
+
+	StepGeom_BSplineCurve::Init(aName, aDegree, aControlPointsList, aCurveForm, aClosedCurve, aSelfIntersect);
+
+	// --- ANDOR componant fields ---
+
+	bSplineCurveWithKnots = new StepGeom_BSplineCurveWithKnots();
+	bSplineCurveWithKnots->Init(aName, aDegree, aControlPointsList, aCurveForm, aClosedCurve, aSelfIntersect, aKnotMultiplicities, aKnots, aKnotSpec);
+
+	// --- ANDOR componant fields ---
+
+	rationalBSplineCurve = new StepGeom_RationalBSplineCurve();
+	rationalBSplineCurve->Init(aName, aDegree, aControlPointsList, aCurveForm, aClosedCurve, aSelfIntersect, aWeightsData);
+}
+
+
+void StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve::SetBSplineCurveWithKnots(const Handle(StepGeom_BSplineCurveWithKnots)& aBSplineCurveWithKnots)
+{
+	bSplineCurveWithKnots = aBSplineCurveWithKnots;
+}
+
+Handle(StepGeom_BSplineCurveWithKnots) StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve::BSplineCurveWithKnots() const
+{
+	return bSplineCurveWithKnots;
+}
+
+void StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve::SetRationalBSplineCurve(const Handle(StepGeom_RationalBSplineCurve)& aRationalBSplineCurve)
+{
+	rationalBSplineCurve = aRationalBSplineCurve;
+}
+
+Handle(StepGeom_RationalBSplineCurve) StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve::RationalBSplineCurve() const
+{
+	return rationalBSplineCurve;
+}
+
+	//--- Specific Methods for AND classe field access ---
+
+
+void StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve::SetKnotMultiplicities(const Handle(TColStd_HArray1OfInteger)& aKnotMultiplicities)
+{
+	bSplineCurveWithKnots->SetKnotMultiplicities(aKnotMultiplicities);
+}
+
+Handle(TColStd_HArray1OfInteger) StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve::KnotMultiplicities() const
+{
+	return bSplineCurveWithKnots->KnotMultiplicities();
+}
+
+Standard_Integer StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve::KnotMultiplicitiesValue(const Standard_Integer num) const
+{
+	return bSplineCurveWithKnots->KnotMultiplicitiesValue(num);
+}
+
+Standard_Integer StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve::NbKnotMultiplicities () const
+{
+	return bSplineCurveWithKnots->NbKnotMultiplicities();
+}
+
+void StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve::SetKnots(const Handle(TColStd_HArray1OfReal)& aKnots)
+{
+	bSplineCurveWithKnots->SetKnots(aKnots);
+}
+
+Handle(TColStd_HArray1OfReal) StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve::Knots() const
+{
+	return bSplineCurveWithKnots->Knots();
+}
+
+Standard_Real StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve::KnotsValue(const Standard_Integer num) const
+{
+	return bSplineCurveWithKnots->KnotsValue(num);
+}
+
+Standard_Integer StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve::NbKnots () const
+{
+	return bSplineCurveWithKnots->NbKnots();
+}
+
+void StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve::SetKnotSpec(const StepGeom_KnotType aKnotSpec)
+{
+	bSplineCurveWithKnots->SetKnotSpec(aKnotSpec);
+}
+
+StepGeom_KnotType StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve::KnotSpec() const
+{
+	return bSplineCurveWithKnots->KnotSpec();
+}
+
+	//--- Specific Methods for AND classe field access ---
+
+
+void StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve::SetWeightsData(const Handle(TColStd_HArray1OfReal)& aWeightsData)
+{
+	rationalBSplineCurve->SetWeightsData(aWeightsData);
+}
+
+Handle(TColStd_HArray1OfReal) StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve::WeightsData() const
+{
+	return rationalBSplineCurve->WeightsData();
+}
+
+Standard_Real StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve::WeightsDataValue(const Standard_Integer num) const
+{
+	return rationalBSplineCurve->WeightsDataValue(num);
+}
+
+Standard_Integer StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve::NbWeightsData () const
+{
+	return rationalBSplineCurve->NbWeightsData();
+}

src/StepGeom/StepGeom_BSplineSurface.cdl

@@ -0,0 +1,73 @@
+-- File:        BSplineSurface.cdl
+-- Created:     Fri Dec  1 11:11:14 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class BSplineSurface from StepGeom 
+
+inherits BoundedSurface from StepGeom 
+
+
+  -- N.B : EXPRESS Complexe SUBTYPE Declaration :
+
+  -- ANDOR ( ONEOF ( b_spline_surface_with_knots uniform_surface quasi_uniform_surface bezier_surface ) rational_b_spline_surface ) 
+
+uses
+
+	Integer from Standard, 
+	HArray2OfCartesianPoint from StepGeom, 
+	BSplineSurfaceForm from StepGeom, 
+	Logical from StepData, 
+	CartesianPoint from StepGeom, 
+	HAsciiString from TCollection
+is
+
+	Create returns mutable BSplineSurface;
+	---Purpose: Returns a BSplineSurface
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aUDegree : Integer from Standard;
+	      aVDegree : Integer from Standard;
+	      aControlPointsList : mutable HArray2OfCartesianPoint from StepGeom;
+	      aSurfaceForm : BSplineSurfaceForm from StepGeom;
+	      aUClosed : Logical from StepData;
+	      aVClosed : Logical from StepData;
+	      aSelfIntersect : Logical from StepData) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetUDegree(me : mutable; aUDegree : Integer);
+	UDegree (me) returns Integer;
+	SetVDegree(me : mutable; aVDegree : Integer);
+	VDegree (me) returns Integer;
+	SetControlPointsList(me : mutable; aControlPointsList : mutable HArray2OfCartesianPoint);
+	ControlPointsList (me) returns mutable HArray2OfCartesianPoint;
+	ControlPointsListValue (me; num1 : Integer;  num2 : Integer) returns mutable CartesianPoint;
+	NbControlPointsListI (me) returns Integer;
+	NbControlPointsListJ (me) returns Integer;
+	SetSurfaceForm(me : mutable; aSurfaceForm : BSplineSurfaceForm);
+	SurfaceForm (me) returns BSplineSurfaceForm;
+	SetUClosed(me : mutable; aUClosed : Logical);
+	UClosed (me) returns Logical;
+	SetVClosed(me : mutable; aVClosed : Logical);
+	VClosed (me) returns Logical;
+	SetSelfIntersect(me : mutable; aSelfIntersect : Logical);
+	SelfIntersect (me) returns Logical;
+
+fields
+
+	uDegree : Integer from Standard;
+	vDegree : Integer from Standard;
+	controlPointsList : HArray2OfCartesianPoint from StepGeom;
+	surfaceForm : BSplineSurfaceForm from StepGeom; -- an Enumeration
+	uClosed : Logical from StepData;
+	vClosed : Logical from StepData;
+	selfIntersect : Logical from StepData;
+
+end BSplineSurface;

src/StepGeom/StepGeom_BSplineSurface.cxx

@@ -0,0 +1,121 @@
+#include <StepGeom_BSplineSurface.ixx>
+
+
+StepGeom_BSplineSurface::StepGeom_BSplineSurface ()  {}
+
+void StepGeom_BSplineSurface::Init(
+	const Handle(TCollection_HAsciiString)& aName)
+{
+
+	StepRepr_RepresentationItem::Init(aName);
+}
+
+void StepGeom_BSplineSurface::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Standard_Integer aUDegree,
+	const Standard_Integer aVDegree,
+	const Handle(StepGeom_HArray2OfCartesianPoint)& aControlPointsList,
+	const StepGeom_BSplineSurfaceForm aSurfaceForm,
+	const StepData_Logical aUClosed,
+	const StepData_Logical aVClosed,
+	const StepData_Logical aSelfIntersect)
+{
+	// --- classe own fields ---
+	uDegree = aUDegree;
+	vDegree = aVDegree;
+	controlPointsList = aControlPointsList;
+	surfaceForm = aSurfaceForm;
+	uClosed = aUClosed;
+	vClosed = aVClosed;
+	selfIntersect = aSelfIntersect;
+	// --- classe inherited fields ---
+	StepRepr_RepresentationItem::Init(aName);
+}
+
+
+void StepGeom_BSplineSurface::SetUDegree(const Standard_Integer aUDegree)
+{
+	uDegree = aUDegree;
+}
+
+Standard_Integer StepGeom_BSplineSurface::UDegree() const
+{
+	return uDegree;
+}
+
+void StepGeom_BSplineSurface::SetVDegree(const Standard_Integer aVDegree)
+{
+	vDegree = aVDegree;
+}
+
+Standard_Integer StepGeom_BSplineSurface::VDegree() const
+{
+	return vDegree;
+}
+
+void StepGeom_BSplineSurface::SetControlPointsList(const Handle(StepGeom_HArray2OfCartesianPoint)& aControlPointsList)
+{
+	controlPointsList = aControlPointsList;
+}
+
+Handle(StepGeom_HArray2OfCartesianPoint) StepGeom_BSplineSurface::ControlPointsList() const
+{
+	return controlPointsList;
+}
+
+Handle(StepGeom_CartesianPoint) StepGeom_BSplineSurface::ControlPointsListValue(const Standard_Integer num1,const Standard_Integer num2) const
+{
+	return controlPointsList->Value(num1,num2);
+}
+
+Standard_Integer StepGeom_BSplineSurface::NbControlPointsListI () const
+{
+	if (controlPointsList.IsNull()) return 0;
+	return controlPointsList->UpperRow() - controlPointsList->LowerRow() + 1;
+}
+
+Standard_Integer StepGeom_BSplineSurface::NbControlPointsListJ () const
+{
+	if (controlPointsList.IsNull()) return 0;
+	return controlPointsList->UpperCol() - controlPointsList->LowerCol() + 1;
+}
+
+void StepGeom_BSplineSurface::SetSurfaceForm(const StepGeom_BSplineSurfaceForm aSurfaceForm)
+{
+	surfaceForm = aSurfaceForm;
+}
+
+StepGeom_BSplineSurfaceForm StepGeom_BSplineSurface::SurfaceForm() const
+{
+	return surfaceForm;
+}
+
+void StepGeom_BSplineSurface::SetUClosed(const StepData_Logical aUClosed)
+{
+	uClosed = aUClosed;
+}
+
+StepData_Logical StepGeom_BSplineSurface::UClosed() const
+{
+	return uClosed;
+}
+
+void StepGeom_BSplineSurface::SetVClosed(const StepData_Logical aVClosed)
+{
+	vClosed = aVClosed;
+}
+
+StepData_Logical StepGeom_BSplineSurface::VClosed() const
+{
+	return vClosed;
+}
+
+void StepGeom_BSplineSurface::SetSelfIntersect(const StepData_Logical aSelfIntersect)
+{
+	selfIntersect = aSelfIntersect;
+}
+
+StepData_Logical StepGeom_BSplineSurface::SelfIntersect() const
+{
+	return selfIntersect;
+}

src/StepGeom/StepGeom_BSplineSurfaceWithKnots.cdl

@@ -0,0 +1,82 @@
+-- File:        BSplineSurfaceWithKnots.cdl
+-- Created:     Fri Dec  1 11:11:15 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class BSplineSurfaceWithKnots from StepGeom 
+
+inherits BSplineSurface from StepGeom 
+
+uses
+
+	HArray1OfInteger from TColStd, 
+	HArray1OfReal from TColStd, 
+	KnotType from StepGeom, 
+	Integer from Standard, 
+	Real from Standard, 
+	HAsciiString from TCollection, 
+	HArray2OfCartesianPoint from StepGeom, 
+	BSplineSurfaceForm from StepGeom, 
+	Logical from StepData
+is
+
+	Create returns mutable BSplineSurfaceWithKnots;
+	---Purpose: Returns a BSplineSurfaceWithKnots
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aUDegree : Integer from Standard;
+	      aVDegree : Integer from Standard;
+	      aControlPointsList : mutable HArray2OfCartesianPoint from StepGeom;
+	      aSurfaceForm : BSplineSurfaceForm from StepGeom;
+	      aUClosed : Logical from StepData;
+	      aVClosed : Logical from StepData;
+	      aSelfIntersect : Logical from StepData) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aUDegree : Integer from Standard;
+	      aVDegree : Integer from Standard;
+	      aControlPointsList : mutable HArray2OfCartesianPoint from StepGeom;
+	      aSurfaceForm : BSplineSurfaceForm from StepGeom;
+	      aUClosed : Logical from StepData;
+	      aVClosed : Logical from StepData;
+	      aSelfIntersect : Logical from StepData;
+	      aUMultiplicities : mutable HArray1OfInteger from TColStd;
+	      aVMultiplicities : mutable HArray1OfInteger from TColStd;
+	      aUKnots : mutable HArray1OfReal from TColStd;
+	      aVKnots : mutable HArray1OfReal from TColStd;
+	      aKnotSpec : KnotType from StepGeom) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetUMultiplicities(me : mutable; aUMultiplicities : mutable HArray1OfInteger);
+	UMultiplicities (me) returns mutable HArray1OfInteger;
+	UMultiplicitiesValue (me; num : Integer) returns Integer;
+	NbUMultiplicities (me) returns Integer;
+	SetVMultiplicities(me : mutable; aVMultiplicities : mutable HArray1OfInteger);
+	VMultiplicities (me) returns mutable HArray1OfInteger;
+	VMultiplicitiesValue (me; num : Integer) returns Integer;
+	NbVMultiplicities (me) returns Integer;
+	SetUKnots(me : mutable; aUKnots : mutable HArray1OfReal);
+	UKnots (me) returns mutable HArray1OfReal;
+	UKnotsValue (me; num : Integer) returns Real;
+	NbUKnots (me) returns Integer;
+	SetVKnots(me : mutable; aVKnots : mutable HArray1OfReal);
+	VKnots (me) returns mutable HArray1OfReal;
+	VKnotsValue (me; num : Integer) returns Real;
+	NbVKnots (me) returns Integer;
+	SetKnotSpec(me : mutable; aKnotSpec : KnotType);
+	KnotSpec (me) returns KnotType;
+
+fields
+
+	uMultiplicities : HArray1OfInteger from TColStd;
+	vMultiplicities : HArray1OfInteger from TColStd;
+	uKnots : HArray1OfReal from TColStd;
+	vKnots : HArray1OfReal from TColStd;
+	knotSpec : KnotType from StepGeom; -- an Enumeration
+
+end BSplineSurfaceWithKnots;

src/StepGeom/StepGeom_BSplineSurfaceWithKnots.cxx

@@ -0,0 +1,134 @@
+#include <StepGeom_BSplineSurfaceWithKnots.ixx>
+
+
+StepGeom_BSplineSurfaceWithKnots::StepGeom_BSplineSurfaceWithKnots ()  {}
+
+void StepGeom_BSplineSurfaceWithKnots::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Standard_Integer aUDegree,
+	const Standard_Integer aVDegree,
+	const Handle(StepGeom_HArray2OfCartesianPoint)& aControlPointsList,
+	const StepGeom_BSplineSurfaceForm aSurfaceForm,
+	const StepData_Logical aUClosed,
+	const StepData_Logical aVClosed,
+	const StepData_Logical aSelfIntersect)
+{
+
+	StepGeom_BSplineSurface::Init(aName, aUDegree, aVDegree, aControlPointsList, aSurfaceForm, aUClosed, aVClosed, aSelfIntersect);
+}
+
+void StepGeom_BSplineSurfaceWithKnots::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Standard_Integer aUDegree,
+	const Standard_Integer aVDegree,
+	const Handle(StepGeom_HArray2OfCartesianPoint)& aControlPointsList,
+	const StepGeom_BSplineSurfaceForm aSurfaceForm,
+	const StepData_Logical aUClosed,
+	const StepData_Logical aVClosed,
+	const StepData_Logical aSelfIntersect,
+	const Handle(TColStd_HArray1OfInteger)& aUMultiplicities,
+	const Handle(TColStd_HArray1OfInteger)& aVMultiplicities,
+	const Handle(TColStd_HArray1OfReal)& aUKnots,
+	const Handle(TColStd_HArray1OfReal)& aVKnots,
+	const StepGeom_KnotType aKnotSpec)
+{
+	// --- classe own fields ---
+	uMultiplicities = aUMultiplicities;
+	vMultiplicities = aVMultiplicities;
+	uKnots = aUKnots;
+	vKnots = aVKnots;
+	knotSpec = aKnotSpec;
+	// --- classe inherited fields ---
+	StepGeom_BSplineSurface::Init(aName, aUDegree, aVDegree, aControlPointsList, aSurfaceForm, aUClosed, aVClosed, aSelfIntersect);
+}
+
+
+void StepGeom_BSplineSurfaceWithKnots::SetUMultiplicities(const Handle(TColStd_HArray1OfInteger)& aUMultiplicities)
+{
+	uMultiplicities = aUMultiplicities;
+}
+
+Handle(TColStd_HArray1OfInteger) StepGeom_BSplineSurfaceWithKnots::UMultiplicities() const
+{
+	return uMultiplicities;
+}
+
+Standard_Integer StepGeom_BSplineSurfaceWithKnots::UMultiplicitiesValue(const Standard_Integer num) const
+{
+	return uMultiplicities->Value(num);
+}
+
+Standard_Integer StepGeom_BSplineSurfaceWithKnots::NbUMultiplicities () const
+{
+	return uMultiplicities->Length();
+}
+
+void StepGeom_BSplineSurfaceWithKnots::SetVMultiplicities(const Handle(TColStd_HArray1OfInteger)& aVMultiplicities)
+{
+	vMultiplicities = aVMultiplicities;
+}
+
+Handle(TColStd_HArray1OfInteger) StepGeom_BSplineSurfaceWithKnots::VMultiplicities() const
+{
+	return vMultiplicities;
+}
+
+Standard_Integer StepGeom_BSplineSurfaceWithKnots::VMultiplicitiesValue(const Standard_Integer num) const
+{
+	return vMultiplicities->Value(num);
+}
+
+Standard_Integer StepGeom_BSplineSurfaceWithKnots::NbVMultiplicities () const
+{
+	return vMultiplicities->Length();
+}
+
+void StepGeom_BSplineSurfaceWithKnots::SetUKnots(const Handle(TColStd_HArray1OfReal)& aUKnots)
+{
+	uKnots = aUKnots;
+}
+
+Handle(TColStd_HArray1OfReal) StepGeom_BSplineSurfaceWithKnots::UKnots() const
+{
+	return uKnots;
+}
+
+Standard_Real StepGeom_BSplineSurfaceWithKnots::UKnotsValue(const Standard_Integer num) const
+{
+	return uKnots->Value(num);
+}
+
+Standard_Integer StepGeom_BSplineSurfaceWithKnots::NbUKnots () const
+{
+	return uKnots->Length();
+}
+
+void StepGeom_BSplineSurfaceWithKnots::SetVKnots(const Handle(TColStd_HArray1OfReal)& aVKnots)
+{
+	vKnots = aVKnots;
+}
+
+Handle(TColStd_HArray1OfReal) StepGeom_BSplineSurfaceWithKnots::VKnots() const
+{
+	return vKnots;
+}
+
+Standard_Real StepGeom_BSplineSurfaceWithKnots::VKnotsValue(const Standard_Integer num) const
+{
+	return vKnots->Value(num);
+}
+
+Standard_Integer StepGeom_BSplineSurfaceWithKnots::NbVKnots () const
+{
+	return vKnots->Length();
+}
+
+void StepGeom_BSplineSurfaceWithKnots::SetKnotSpec(const StepGeom_KnotType aKnotSpec)
+{
+	knotSpec = aKnotSpec;
+}
+
+StepGeom_KnotType StepGeom_BSplineSurfaceWithKnots::KnotSpec() const
+{
+	return knotSpec;
+}

src/StepGeom/StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface.cdl

@@ -0,0 +1,112 @@
+-- File:        BSplineSurfaceWithKnotsAndRationalBSplineSurface.cdl
+-- Created:     Fri Dec  1 11:11:32 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class BSplineSurfaceWithKnotsAndRationalBSplineSurface from StepGeom 
+
+inherits BSplineSurface from StepGeom 
+
+
+	--- This classe is an implementation of EXPRESS
+	--  ANDOR Subtype Declaration.
+uses
+
+	BSplineSurfaceWithKnots from StepGeom, 
+	RationalBSplineSurface from StepGeom, 
+	HAsciiString from TCollection, 
+	Integer from Standard, 
+	HArray2OfCartesianPoint from StepGeom, 
+	BSplineSurfaceForm from StepGeom, 
+	Logical from StepData, 
+	HArray1OfInteger from TColStd, 
+	HArray1OfReal from TColStd, 
+	HArray2OfReal from TColStd, 
+	KnotType from StepGeom
+is
+
+	Create returns mutable BSplineSurfaceWithKnotsAndRationalBSplineSurface;
+	---Purpose: Returns a BSplineSurfaceWithKnotsAndRationalBSplineSurface
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aUDegree : Integer from Standard;
+	      aVDegree : Integer from Standard;
+	      aControlPointsList : mutable HArray2OfCartesianPoint from StepGeom;
+	      aSurfaceForm : BSplineSurfaceForm from StepGeom;
+	      aUClosed : Logical from StepData;
+	      aVClosed : Logical from StepData;
+	      aSelfIntersect : Logical from StepData) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aUDegree : Integer from Standard;
+	      aVDegree : Integer from Standard;
+	      aControlPointsList : mutable HArray2OfCartesianPoint from StepGeom;
+	      aSurfaceForm : BSplineSurfaceForm from StepGeom;
+	      aUClosed : Logical from StepData;
+	      aVClosed : Logical from StepData;
+	      aSelfIntersect : Logical from StepData;
+	      aBSplineSurfaceWithKnots : mutable BSplineSurfaceWithKnots from StepGeom;
+	      aRationalBSplineSurface : mutable RationalBSplineSurface from StepGeom) is virtual;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aUDegree : Integer from Standard;
+	      aVDegree : Integer from Standard;
+	      aControlPointsList : mutable HArray2OfCartesianPoint from StepGeom;
+	      aSurfaceForm : BSplineSurfaceForm from StepGeom;
+	      aUClosed : Logical from StepData;
+	      aVClosed : Logical from StepData;
+	      aSelfIntersect : Logical from StepData;
+	      aUMultiplicities : mutable HArray1OfInteger from TColStd;
+	      aVMultiplicities : mutable HArray1OfInteger from TColStd;
+	      aUKnots : mutable HArray1OfReal from TColStd;
+	      aVKnots : mutable HArray1OfReal from TColStd;
+	      aKnotSpec : KnotType from StepGeom;
+	      aWeightsData : mutable HArray2OfReal from TColStd) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetBSplineSurfaceWithKnots(me : mutable; aBSplineSurfaceWithKnots : mutable BSplineSurfaceWithKnots);
+	BSplineSurfaceWithKnots (me) returns mutable BSplineSurfaceWithKnots;
+	SetRationalBSplineSurface(me : mutable; aRationalBSplineSurface : mutable RationalBSplineSurface);
+	RationalBSplineSurface (me) returns mutable RationalBSplineSurface;
+
+	-- Specific Methods for ANDOR Field Data Access --
+
+	SetUMultiplicities(me : mutable; aUMultiplicities : mutable HArray1OfInteger);
+	UMultiplicities (me) returns mutable HArray1OfInteger;
+	UMultiplicitiesValue (me; num : Integer) returns Integer;
+	NbUMultiplicities (me) returns Integer;
+	SetVMultiplicities(me : mutable; aVMultiplicities : mutable HArray1OfInteger);
+	VMultiplicities (me) returns mutable HArray1OfInteger;
+	VMultiplicitiesValue (me; num : Integer) returns Integer;
+	NbVMultiplicities (me) returns Integer;
+	SetUKnots(me : mutable; aUKnots : mutable HArray1OfReal);
+	UKnots (me) returns mutable HArray1OfReal;
+	UKnotsValue (me; num : Integer) returns Real;
+	NbUKnots (me) returns Integer;
+	SetVKnots(me : mutable; aVKnots : mutable HArray1OfReal);
+	VKnots (me) returns mutable HArray1OfReal;
+	VKnotsValue (me; num : Integer) returns Real;
+	NbVKnots (me) returns Integer;
+	SetKnotSpec(me : mutable; aKnotSpec : KnotType);
+	KnotSpec (me) returns KnotType;
+
+	-- Specific Methods for ANDOR Field Data Access --
+
+	SetWeightsData(me : mutable; aWeightsData : mutable HArray2OfReal);
+	WeightsData (me) returns mutable HArray2OfReal;
+	WeightsDataValue (me; num1 : Integer;  num2 : Integer) returns Real;
+	NbWeightsDataI (me) returns Integer;
+	NbWeightsDataJ (me) returns Integer;
+
+fields
+
+	bSplineSurfaceWithKnots : BSplineSurfaceWithKnots from StepGeom;
+	rationalBSplineSurface : RationalBSplineSurface from StepGeom;
+
+end BSplineSurfaceWithKnotsAndRationalBSplineSurface;

src/StepGeom/StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface.cxx

@@ -0,0 +1,215 @@
+#include <StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface.ixx>
+
+#include <StepGeom_BSplineSurfaceWithKnots.hxx>
+
+#include <StepGeom_RationalBSplineSurface.hxx>
+
+
+StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface ()  {}
+
+void StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Standard_Integer aUDegree,
+	const Standard_Integer aVDegree,
+	const Handle(StepGeom_HArray2OfCartesianPoint)& aControlPointsList,
+	const StepGeom_BSplineSurfaceForm aSurfaceForm,
+	const StepData_Logical aUClosed,
+	const StepData_Logical aVClosed,
+	const StepData_Logical aSelfIntersect)
+{
+
+	StepGeom_BSplineSurface::Init(aName, aUDegree, aVDegree, aControlPointsList, aSurfaceForm, aUClosed, aVClosed, aSelfIntersect);
+}
+
+void StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Standard_Integer aUDegree,
+	const Standard_Integer aVDegree,
+	const Handle(StepGeom_HArray2OfCartesianPoint)& aControlPointsList,
+	const StepGeom_BSplineSurfaceForm aSurfaceForm,
+	const StepData_Logical aUClosed,
+	const StepData_Logical aVClosed,
+	const StepData_Logical aSelfIntersect,
+	const Handle(StepGeom_BSplineSurfaceWithKnots)& aBSplineSurfaceWithKnots,
+	const Handle(StepGeom_RationalBSplineSurface)& aRationalBSplineSurface)
+{
+	// --- classe own fields ---
+	bSplineSurfaceWithKnots = aBSplineSurfaceWithKnots;
+	rationalBSplineSurface = aRationalBSplineSurface;
+	// --- classe inherited fields ---
+	StepGeom_BSplineSurface::Init(aName, aUDegree, aVDegree, aControlPointsList, aSurfaceForm, aUClosed, aVClosed, aSelfIntersect);
+}
+
+
+void StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Standard_Integer aUDegree,
+	const Standard_Integer aVDegree,
+	const Handle(StepGeom_HArray2OfCartesianPoint)& aControlPointsList,
+	const StepGeom_BSplineSurfaceForm aSurfaceForm,
+	const StepData_Logical aUClosed,
+	const StepData_Logical aVClosed,
+	const StepData_Logical aSelfIntersect,
+	const Handle(TColStd_HArray1OfInteger)& aUMultiplicities,
+	const Handle(TColStd_HArray1OfInteger)& aVMultiplicities,
+	const Handle(TColStd_HArray1OfReal)& aUKnots,
+	const Handle(TColStd_HArray1OfReal)& aVKnots,
+	const StepGeom_KnotType aKnotSpec,
+	const Handle(TColStd_HArray2OfReal)& aWeightsData)
+{
+	// --- classe inherited fields ---
+
+	StepGeom_BSplineSurface::Init(aName, aUDegree, aVDegree, aControlPointsList, aSurfaceForm, aUClosed, aVClosed, aSelfIntersect);
+
+	// --- ANDOR componant fields ---
+
+	bSplineSurfaceWithKnots = new StepGeom_BSplineSurfaceWithKnots();
+	bSplineSurfaceWithKnots->Init(aName, aUDegree, aVDegree, aControlPointsList, aSurfaceForm, aUClosed, aVClosed, aSelfIntersect, aUMultiplicities, aVMultiplicities, aUKnots, aVKnots, aKnotSpec);
+
+	// --- ANDOR componant fields ---
+
+	rationalBSplineSurface = new StepGeom_RationalBSplineSurface();
+	rationalBSplineSurface->Init(aName, aUDegree, aVDegree, aControlPointsList, aSurfaceForm, aUClosed, aVClosed, aSelfIntersect, aWeightsData);
+}
+
+
+void StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::SetBSplineSurfaceWithKnots(const Handle(StepGeom_BSplineSurfaceWithKnots)& aBSplineSurfaceWithKnots)
+{
+	bSplineSurfaceWithKnots = aBSplineSurfaceWithKnots;
+}
+
+Handle(StepGeom_BSplineSurfaceWithKnots) StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::BSplineSurfaceWithKnots() const
+{
+	return bSplineSurfaceWithKnots;
+}
+
+void StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::SetRationalBSplineSurface(const Handle(StepGeom_RationalBSplineSurface)& aRationalBSplineSurface)
+{
+	rationalBSplineSurface = aRationalBSplineSurface;
+}
+
+Handle(StepGeom_RationalBSplineSurface) StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::RationalBSplineSurface() const
+{
+	return rationalBSplineSurface;
+}
+
+	//--- Specific Methods for AND classe field access ---
+
+
+void StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::SetUMultiplicities(const Handle(TColStd_HArray1OfInteger)& aUMultiplicities)
+{
+	bSplineSurfaceWithKnots->SetUMultiplicities(aUMultiplicities);
+}
+
+Handle(TColStd_HArray1OfInteger) StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::UMultiplicities() const
+{
+	return bSplineSurfaceWithKnots->UMultiplicities();
+}
+
+Standard_Integer StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::UMultiplicitiesValue(const Standard_Integer num) const
+{
+	return bSplineSurfaceWithKnots->UMultiplicitiesValue(num);
+}
+
+Standard_Integer StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::NbUMultiplicities () const
+{
+	return bSplineSurfaceWithKnots->NbUMultiplicities();
+}
+
+void StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::SetVMultiplicities(const Handle(TColStd_HArray1OfInteger)& aVMultiplicities)
+{
+	bSplineSurfaceWithKnots->SetVMultiplicities(aVMultiplicities);
+}
+
+Handle(TColStd_HArray1OfInteger) StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::VMultiplicities() const
+{
+	return bSplineSurfaceWithKnots->VMultiplicities();
+}
+
+Standard_Integer StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::VMultiplicitiesValue(const Standard_Integer num) const
+{
+	return bSplineSurfaceWithKnots->VMultiplicitiesValue(num);
+}
+
+Standard_Integer StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::NbVMultiplicities () const
+{
+	return bSplineSurfaceWithKnots->NbVMultiplicities();
+}
+
+void StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::SetUKnots(const Handle(TColStd_HArray1OfReal)& aUKnots)
+{
+	bSplineSurfaceWithKnots->SetUKnots(aUKnots);
+}
+
+Handle(TColStd_HArray1OfReal) StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::UKnots() const
+{
+	return bSplineSurfaceWithKnots->UKnots();
+}
+
+Standard_Real StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::UKnotsValue(const Standard_Integer num) const
+{
+	return bSplineSurfaceWithKnots->UKnotsValue(num);
+}
+
+Standard_Integer StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::NbUKnots () const
+{
+	return bSplineSurfaceWithKnots->NbUKnots();
+}
+
+void StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::SetVKnots(const Handle(TColStd_HArray1OfReal)& aVKnots)
+{
+	bSplineSurfaceWithKnots->SetVKnots(aVKnots);
+}
+
+Handle(TColStd_HArray1OfReal) StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::VKnots() const
+{
+	return bSplineSurfaceWithKnots->VKnots();
+}
+
+Standard_Real StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::VKnotsValue(const Standard_Integer num) const
+{
+	return bSplineSurfaceWithKnots->VKnotsValue(num);
+}
+
+Standard_Integer StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::NbVKnots () const
+{
+	return bSplineSurfaceWithKnots->NbVKnots();
+}
+
+void StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::SetKnotSpec(const StepGeom_KnotType aKnotSpec)
+{
+	bSplineSurfaceWithKnots->SetKnotSpec(aKnotSpec);
+}
+
+StepGeom_KnotType StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::KnotSpec() const
+{
+	return bSplineSurfaceWithKnots->KnotSpec();
+}
+
+	//--- Specific Methods for AND classe field access ---
+
+
+void StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::SetWeightsData(const Handle(TColStd_HArray2OfReal)& aWeightsData)
+{
+	rationalBSplineSurface->SetWeightsData(aWeightsData);
+}
+
+Handle(TColStd_HArray2OfReal) StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::WeightsData() const
+{
+	return rationalBSplineSurface->WeightsData();
+}
+
+Standard_Real StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::WeightsDataValue(const Standard_Integer num1,const Standard_Integer num2) const
+{
+	return rationalBSplineSurface->WeightsDataValue(num1,num2);
+}
+
+Standard_Integer StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::NbWeightsDataI () const
+{
+	return rationalBSplineSurface->NbWeightsDataI ();
+}
+
+Standard_Integer StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface::NbWeightsDataJ () const
+{
+	return rationalBSplineSurface->NbWeightsDataJ ();
+}

src/StepGeom/StepGeom_BezierCurve.cdl

@@ -0,0 +1,24 @@
+-- File:        BezierCurve.cdl
+-- Created:     Fri Dec  1 11:11:15 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class BezierCurve from StepGeom 
+
+inherits BSplineCurve from StepGeom 
+
+uses
+
+	HAsciiString from TCollection, 
+	Integer from Standard, 
+	HArray1OfCartesianPoint from StepGeom, 
+	BSplineCurveForm from StepGeom, 
+	Logical from StepData
+is
+
+	Create returns mutable BezierCurve;
+	---Purpose: Returns a BezierCurve
+
+
+end BezierCurve;

src/StepGeom/StepGeom_BezierCurve.cxx

@@ -0,0 +1,5 @@
+#include <StepGeom_BezierCurve.ixx>
+
+
+StepGeom_BezierCurve::StepGeom_BezierCurve ()  {}
+

src/StepGeom/StepGeom_BezierCurveAndRationalBSplineCurve.cdl

@@ -0,0 +1,80 @@
+-- File:        BezierCurveAndRationalBSplineCurve.cdl
+-- Created:     Fri Dec  1 11:11:32 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class BezierCurveAndRationalBSplineCurve from StepGeom 
+
+inherits BSplineCurve from StepGeom 
+
+
+	--- This classe is an implementation of EXPRESS
+	--  ANDOR Subtype Declaration.
+uses
+
+	BezierCurve from StepGeom, 
+	RationalBSplineCurve from StepGeom, 
+	HAsciiString from TCollection, 
+	Integer from Standard, 
+	HArray1OfCartesianPoint from StepGeom, 
+	BSplineCurveForm from StepGeom, 
+	Logical from StepData, 
+	HArray1OfReal from TColStd, 
+	Real from Standard
+is
+
+	Create returns mutable BezierCurveAndRationalBSplineCurve;
+	---Purpose: Returns a BezierCurveAndRationalBSplineCurve
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aDegree : Integer from Standard;
+	      aControlPointsList : mutable HArray1OfCartesianPoint from StepGeom;
+	      aCurveForm : BSplineCurveForm from StepGeom;
+	      aClosedCurve : Logical from StepData;
+	      aSelfIntersect : Logical from StepData) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aDegree : Integer from Standard;
+	      aControlPointsList : mutable HArray1OfCartesianPoint from StepGeom;
+	      aCurveForm : BSplineCurveForm from StepGeom;
+	      aClosedCurve : Logical from StepData;
+	      aSelfIntersect : Logical from StepData;
+	      aBezierCurve : mutable BezierCurve from StepGeom;
+	      aRationalBSplineCurve : mutable RationalBSplineCurve from StepGeom) is virtual;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aDegree : Integer from Standard;
+	      aControlPointsList : mutable HArray1OfCartesianPoint from StepGeom;
+	      aCurveForm : BSplineCurveForm from StepGeom;
+	      aClosedCurve : Logical from StepData;
+	      aSelfIntersect : Logical from StepData;
+	      aWeightsData : mutable HArray1OfReal from TColStd) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetBezierCurve(me : mutable; aBezierCurve : mutable BezierCurve);
+	BezierCurve (me) returns mutable BezierCurve;
+	SetRationalBSplineCurve(me : mutable; aRationalBSplineCurve : mutable RationalBSplineCurve);
+	RationalBSplineCurve (me) returns mutable RationalBSplineCurve;
+
+	-- Specific Methods for ANDOR Field Data Access --
+
+
+	-- Specific Methods for ANDOR Field Data Access --
+
+	SetWeightsData(me : mutable; aWeightsData : mutable HArray1OfReal);
+	WeightsData (me) returns mutable HArray1OfReal;
+	WeightsDataValue (me; num : Integer) returns Real;
+	NbWeightsData (me) returns Integer;
+
+fields
+
+	bezierCurve : BezierCurve from StepGeom;
+	rationalBSplineCurve : RationalBSplineCurve from StepGeom;
+
+end BezierCurveAndRationalBSplineCurve;

src/StepGeom/StepGeom_BezierCurveAndRationalBSplineCurve.cxx

@@ -0,0 +1,109 @@
+#include <StepGeom_BezierCurveAndRationalBSplineCurve.ixx>
+
+#include <StepGeom_BezierCurve.hxx>
+
+#include <StepGeom_RationalBSplineCurve.hxx>
+
+
+StepGeom_BezierCurveAndRationalBSplineCurve::StepGeom_BezierCurveAndRationalBSplineCurve ()  {}
+
+void StepGeom_BezierCurveAndRationalBSplineCurve::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Standard_Integer aDegree,
+	const Handle(StepGeom_HArray1OfCartesianPoint)& aControlPointsList,
+	const StepGeom_BSplineCurveForm aCurveForm,
+	const StepData_Logical aClosedCurve,
+	const StepData_Logical aSelfIntersect)
+{
+
+	StepGeom_BSplineCurve::Init(aName, aDegree, aControlPointsList, aCurveForm, aClosedCurve, aSelfIntersect);
+}
+
+void StepGeom_BezierCurveAndRationalBSplineCurve::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Standard_Integer aDegree,
+	const Handle(StepGeom_HArray1OfCartesianPoint)& aControlPointsList,
+	const StepGeom_BSplineCurveForm aCurveForm,
+	const StepData_Logical aClosedCurve,
+	const StepData_Logical aSelfIntersect,
+	const Handle(StepGeom_BezierCurve)& aBezierCurve,
+	const Handle(StepGeom_RationalBSplineCurve)& aRationalBSplineCurve)
+{
+	// --- classe own fields ---
+	bezierCurve = aBezierCurve;
+	rationalBSplineCurve = aRationalBSplineCurve;
+	// --- classe inherited fields ---
+	StepGeom_BSplineCurve::Init(aName, aDegree, aControlPointsList, aCurveForm, aClosedCurve, aSelfIntersect);
+}
+
+
+void StepGeom_BezierCurveAndRationalBSplineCurve::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Standard_Integer aDegree,
+	const Handle(StepGeom_HArray1OfCartesianPoint)& aControlPointsList,
+	const StepGeom_BSplineCurveForm aCurveForm,
+	const StepData_Logical aClosedCurve,
+	const StepData_Logical aSelfIntersect,
+	const Handle(TColStd_HArray1OfReal)& aWeightsData)
+{
+	// --- classe inherited fields ---
+
+	StepGeom_BSplineCurve::Init(aName, aDegree, aControlPointsList, aCurveForm, aClosedCurve, aSelfIntersect);
+
+	// --- ANDOR componant fields ---
+
+	bezierCurve = new StepGeom_BezierCurve();
+	bezierCurve->Init(aName, aDegree, aControlPointsList, aCurveForm, aClosedCurve, aSelfIntersect);
+
+	// --- ANDOR componant fields ---
+
+	rationalBSplineCurve = new StepGeom_RationalBSplineCurve();
+	rationalBSplineCurve->Init(aName, aDegree, aControlPointsList, aCurveForm, aClosedCurve, aSelfIntersect, aWeightsData);
+}
+
+
+void StepGeom_BezierCurveAndRationalBSplineCurve::SetBezierCurve(const Handle(StepGeom_BezierCurve)& aBezierCurve)
+{
+	bezierCurve = aBezierCurve;
+}
+
+Handle(StepGeom_BezierCurve) StepGeom_BezierCurveAndRationalBSplineCurve::BezierCurve() const
+{
+	return bezierCurve;
+}
+
+void StepGeom_BezierCurveAndRationalBSplineCurve::SetRationalBSplineCurve(const Handle(StepGeom_RationalBSplineCurve)& aRationalBSplineCurve)
+{
+	rationalBSplineCurve = aRationalBSplineCurve;
+}
+
+Handle(StepGeom_RationalBSplineCurve) StepGeom_BezierCurveAndRationalBSplineCurve::RationalBSplineCurve() const
+{
+	return rationalBSplineCurve;
+}
+
+	//--- Specific Methods for AND classe field access ---
+
+
+	//--- Specific Methods for AND classe field access ---
+
+
+void StepGeom_BezierCurveAndRationalBSplineCurve::SetWeightsData(const Handle(TColStd_HArray1OfReal)& aWeightsData)
+{
+	rationalBSplineCurve->SetWeightsData(aWeightsData);
+}
+
+Handle(TColStd_HArray1OfReal) StepGeom_BezierCurveAndRationalBSplineCurve::WeightsData() const
+{
+	return rationalBSplineCurve->WeightsData();
+}
+
+Standard_Real StepGeom_BezierCurveAndRationalBSplineCurve::WeightsDataValue(const Standard_Integer num) const
+{
+	return rationalBSplineCurve->WeightsDataValue(num);
+}
+
+Standard_Integer StepGeom_BezierCurveAndRationalBSplineCurve::NbWeightsData () const
+{
+	return rationalBSplineCurve->NbWeightsData();
+}

src/StepGeom/StepGeom_BezierSurface.cdl

@@ -0,0 +1,24 @@
+-- File:        BezierSurface.cdl
+-- Created:     Fri Dec  1 11:11:15 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class BezierSurface from StepGeom 
+
+inherits BSplineSurface from StepGeom 
+
+uses
+
+	HAsciiString from TCollection, 
+	Integer from Standard, 
+	HArray2OfCartesianPoint from StepGeom, 
+	BSplineSurfaceForm from StepGeom, 
+	Logical from StepData
+is
+
+	Create returns mutable BezierSurface;
+	---Purpose: Returns a BezierSurface
+
+
+end BezierSurface;

src/StepGeom/StepGeom_BezierSurface.cxx

@@ -0,0 +1,5 @@
+#include <StepGeom_BezierSurface.ixx>
+
+
+StepGeom_BezierSurface::StepGeom_BezierSurface ()  {}
+

src/StepGeom/StepGeom_BezierSurfaceAndRationalBSplineSurface.cdl

@@ -0,0 +1,87 @@
+-- File:        BezierSurfaceAndRationalBSplineSurface.cdl
+-- Created:     Fri Dec  1 11:11:33 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class BezierSurfaceAndRationalBSplineSurface from StepGeom 
+
+inherits BSplineSurface from StepGeom 
+
+
+	--- This classe is an implementation of EXPRESS
+	--  ANDOR Subtype Declaration.
+uses
+
+	BezierSurface from StepGeom, 
+	RationalBSplineSurface from StepGeom, 
+	HAsciiString from TCollection, 
+	Integer from Standard, 
+	HArray2OfCartesianPoint from StepGeom, 
+	BSplineSurfaceForm from StepGeom, 
+	Logical from StepData, 
+	HArray2OfReal from TColStd, 
+	Real from Standard
+is
+
+	Create returns mutable BezierSurfaceAndRationalBSplineSurface;
+	---Purpose: Returns a BezierSurfaceAndRationalBSplineSurface
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aUDegree : Integer from Standard;
+	      aVDegree : Integer from Standard;
+	      aControlPointsList : mutable HArray2OfCartesianPoint from StepGeom;
+	      aSurfaceForm : BSplineSurfaceForm from StepGeom;
+	      aUClosed : Logical from StepData;
+	      aVClosed : Logical from StepData;
+	      aSelfIntersect : Logical from StepData) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aUDegree : Integer from Standard;
+	      aVDegree : Integer from Standard;
+	      aControlPointsList : mutable HArray2OfCartesianPoint from StepGeom;
+	      aSurfaceForm : BSplineSurfaceForm from StepGeom;
+	      aUClosed : Logical from StepData;
+	      aVClosed : Logical from StepData;
+	      aSelfIntersect : Logical from StepData;
+	      aBezierSurface : mutable BezierSurface from StepGeom;
+	      aRationalBSplineSurface : mutable RationalBSplineSurface from StepGeom) is virtual;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aUDegree : Integer from Standard;
+	      aVDegree : Integer from Standard;
+	      aControlPointsList : mutable HArray2OfCartesianPoint from StepGeom;
+	      aSurfaceForm : BSplineSurfaceForm from StepGeom;
+	      aUClosed : Logical from StepData;
+	      aVClosed : Logical from StepData;
+	      aSelfIntersect : Logical from StepData;
+	      aWeightsData : mutable HArray2OfReal from TColStd) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetBezierSurface(me : mutable; aBezierSurface : mutable BezierSurface);
+	BezierSurface (me) returns mutable BezierSurface;
+	SetRationalBSplineSurface(me : mutable; aRationalBSplineSurface : mutable RationalBSplineSurface);
+	RationalBSplineSurface (me) returns mutable RationalBSplineSurface;
+
+	-- Specific Methods for ANDOR Field Data Access --
+
+
+	-- Specific Methods for ANDOR Field Data Access --
+
+	SetWeightsData(me : mutable; aWeightsData : mutable HArray2OfReal);
+	WeightsData (me) returns mutable HArray2OfReal;
+	WeightsDataValue (me; num1 : Integer;  num2 : Integer) returns Real;
+	NbWeightsDataI (me) returns Integer;
+	NbWeightsDataJ (me) returns Integer;
+
+fields
+
+	bezierSurface : BezierSurface from StepGeom;
+	rationalBSplineSurface : RationalBSplineSurface from StepGeom;
+
+end BezierSurfaceAndRationalBSplineSurface;

src/StepGeom/StepGeom_BezierSurfaceAndRationalBSplineSurface.cxx

@@ -0,0 +1,120 @@
+#include <StepGeom_BezierSurfaceAndRationalBSplineSurface.ixx>
+
+#include <StepGeom_BezierSurface.hxx>
+
+#include <StepGeom_RationalBSplineSurface.hxx>
+
+
+StepGeom_BezierSurfaceAndRationalBSplineSurface::StepGeom_BezierSurfaceAndRationalBSplineSurface ()  {}
+
+void StepGeom_BezierSurfaceAndRationalBSplineSurface::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Standard_Integer aUDegree,
+	const Standard_Integer aVDegree,
+	const Handle(StepGeom_HArray2OfCartesianPoint)& aControlPointsList,
+	const StepGeom_BSplineSurfaceForm aSurfaceForm,
+	const StepData_Logical aUClosed,
+	const StepData_Logical aVClosed,
+	const StepData_Logical aSelfIntersect)
+{
+
+	StepGeom_BSplineSurface::Init(aName, aUDegree, aVDegree, aControlPointsList, aSurfaceForm, aUClosed, aVClosed, aSelfIntersect);
+}
+
+void StepGeom_BezierSurfaceAndRationalBSplineSurface::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Standard_Integer aUDegree,
+	const Standard_Integer aVDegree,
+	const Handle(StepGeom_HArray2OfCartesianPoint)& aControlPointsList,
+	const StepGeom_BSplineSurfaceForm aSurfaceForm,
+	const StepData_Logical aUClosed,
+	const StepData_Logical aVClosed,
+	const StepData_Logical aSelfIntersect,
+	const Handle(StepGeom_BezierSurface)& aBezierSurface,
+	const Handle(StepGeom_RationalBSplineSurface)& aRationalBSplineSurface)
+{
+	// --- classe own fields ---
+	bezierSurface = aBezierSurface;
+	rationalBSplineSurface = aRationalBSplineSurface;
+	// --- classe inherited fields ---
+	StepGeom_BSplineSurface::Init(aName, aUDegree, aVDegree, aControlPointsList, aSurfaceForm, aUClosed, aVClosed, aSelfIntersect);
+}
+
+
+void StepGeom_BezierSurfaceAndRationalBSplineSurface::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Standard_Integer aUDegree,
+	const Standard_Integer aVDegree,
+	const Handle(StepGeom_HArray2OfCartesianPoint)& aControlPointsList,
+	const StepGeom_BSplineSurfaceForm aSurfaceForm,
+	const StepData_Logical aUClosed,
+	const StepData_Logical aVClosed,
+	const StepData_Logical aSelfIntersect,
+	const Handle(TColStd_HArray2OfReal)& aWeightsData)
+{
+	// --- classe inherited fields ---
+
+	StepGeom_BSplineSurface::Init(aName, aUDegree, aVDegree, aControlPointsList, aSurfaceForm, aUClosed, aVClosed, aSelfIntersect);
+
+	// --- ANDOR componant fields ---
+
+	bezierSurface = new StepGeom_BezierSurface();
+	bezierSurface->Init(aName, aUDegree, aVDegree, aControlPointsList, aSurfaceForm, aUClosed, aVClosed, aSelfIntersect);
+
+	// --- ANDOR componant fields ---
+
+	rationalBSplineSurface = new StepGeom_RationalBSplineSurface();
+	rationalBSplineSurface->Init(aName, aUDegree, aVDegree, aControlPointsList, aSurfaceForm, aUClosed, aVClosed, aSelfIntersect, aWeightsData);
+}
+
+
+void StepGeom_BezierSurfaceAndRationalBSplineSurface::SetBezierSurface(const Handle(StepGeom_BezierSurface)& aBezierSurface)
+{
+	bezierSurface = aBezierSurface;
+}
+
+Handle(StepGeom_BezierSurface) StepGeom_BezierSurfaceAndRationalBSplineSurface::BezierSurface() const
+{
+	return bezierSurface;
+}
+
+void StepGeom_BezierSurfaceAndRationalBSplineSurface::SetRationalBSplineSurface(const Handle(StepGeom_RationalBSplineSurface)& aRationalBSplineSurface)
+{
+	rationalBSplineSurface = aRationalBSplineSurface;
+}
+
+Handle(StepGeom_RationalBSplineSurface) StepGeom_BezierSurfaceAndRationalBSplineSurface::RationalBSplineSurface() const
+{
+	return rationalBSplineSurface;
+}
+
+	//--- Specific Methods for AND classe field access ---
+
+
+	//--- Specific Methods for AND classe field access ---
+
+
+void StepGeom_BezierSurfaceAndRationalBSplineSurface::SetWeightsData(const Handle(TColStd_HArray2OfReal)& aWeightsData)
+{
+	rationalBSplineSurface->SetWeightsData(aWeightsData);
+}
+
+Handle(TColStd_HArray2OfReal) StepGeom_BezierSurfaceAndRationalBSplineSurface::WeightsData() const
+{
+	return rationalBSplineSurface->WeightsData();
+}
+
+Standard_Real StepGeom_BezierSurfaceAndRationalBSplineSurface::WeightsDataValue(const Standard_Integer num1,const Standard_Integer num2) const
+{
+	return rationalBSplineSurface->WeightsDataValue(num1,num2);
+}
+
+Standard_Integer StepGeom_BezierSurfaceAndRationalBSplineSurface::NbWeightsDataI () const
+{
+	return rationalBSplineSurface->NbWeightsDataI ();
+}
+
+Standard_Integer StepGeom_BezierSurfaceAndRationalBSplineSurface::NbWeightsDataJ () const
+{
+	return rationalBSplineSurface->NbWeightsDataJ ();
+}

src/StepGeom/StepGeom_BoundaryCurve.cdl

@@ -0,0 +1,22 @@
+-- File:        BoundaryCurve.cdl
+-- Created:     Fri Dec  1 11:11:15 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class BoundaryCurve from StepGeom 
+
+inherits CompositeCurveOnSurface from StepGeom 
+
+uses
+
+	HAsciiString from TCollection, 
+	HArray1OfCompositeCurveSegment from StepGeom, 
+	Logical from StepData
+is
+
+	Create returns mutable BoundaryCurve;
+	---Purpose: Returns a BoundaryCurve
+
+
+end BoundaryCurve;

src/StepGeom/StepGeom_BoundaryCurve.cxx

@@ -0,0 +1,5 @@
+#include <StepGeom_BoundaryCurve.ixx>
+
+
+StepGeom_BoundaryCurve::StepGeom_BoundaryCurve ()  {}
+

src/StepGeom/StepGeom_BoundedCurve.cdl

@@ -0,0 +1,20 @@
+-- File:        BoundedCurve.cdl
+-- Created:     Fri Dec  1 11:11:15 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class BoundedCurve from StepGeom 
+
+inherits Curve from StepGeom 
+
+uses
+
+	HAsciiString from TCollection
+is
+
+	Create returns mutable BoundedCurve;
+	---Purpose: Returns a BoundedCurve
+
+
+end BoundedCurve;

src/StepGeom/StepGeom_BoundedCurve.cxx

@@ -0,0 +1,5 @@
+#include <StepGeom_BoundedCurve.ixx>
+
+
+StepGeom_BoundedCurve::StepGeom_BoundedCurve ()  {}
+

src/StepGeom/StepGeom_BoundedSurface.cdl

@@ -0,0 +1,20 @@
+-- File:        BoundedSurface.cdl
+-- Created:     Fri Dec  1 11:11:15 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class BoundedSurface from StepGeom 
+
+inherits Surface from StepGeom 
+
+uses
+
+	HAsciiString from TCollection
+is
+
+	Create returns mutable BoundedSurface;
+	---Purpose: Returns a BoundedSurface
+
+
+end BoundedSurface;

src/StepGeom/StepGeom_BoundedSurface.cxx

@@ -0,0 +1,5 @@
+#include <StepGeom_BoundedSurface.ixx>
+
+
+StepGeom_BoundedSurface::StepGeom_BoundedSurface ()  {}
+

src/StepGeom/StepGeom_CartesianPoint.cdl

@@ -0,0 +1,50 @@
+-- File:        CartesianPoint.cdl
+-- Created:     Fri Dec  1 11:11:16 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class CartesianPoint from StepGeom 
+
+inherits Point from StepGeom 
+
+uses
+
+	HArray1OfReal from TColStd, 
+	Real from Standard, 
+	HAsciiString from TCollection
+is
+
+	Create returns mutable CartesianPoint;
+	---Purpose: Returns a CartesianPoint
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aCoordinates : mutable HArray1OfReal from TColStd) is virtual;
+
+    	Init2D (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      X,Y : Real);
+
+    	Init3D (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      X,Y,Z : Real);
+
+	-- Specific Methods for Field Data Access --
+
+	SetCoordinates(me : mutable; aCoordinates : mutable HArray1OfReal);
+	Coordinates (me) returns mutable HArray1OfReal;
+	CoordinatesValue (me; num : Integer) returns Real;
+	NbCoordinates (me) returns Integer;
+
+fields
+
+    nbcoord : Integer; -- optimised formula
+    coords  : Real[3];
+--	coordinates : HArray1OfReal from TColStd;
+
+end CartesianPoint;

src/StepGeom/StepGeom_CartesianPoint.cxx

@@ -0,0 +1,78 @@
+#include <StepGeom_CartesianPoint.ixx>
+
+
+StepGeom_CartesianPoint::StepGeom_CartesianPoint ()  {}
+
+void StepGeom_CartesianPoint::Init(
+	const Handle(TCollection_HAsciiString)& aName)
+{
+
+	StepRepr_RepresentationItem::Init(aName);
+}
+
+void StepGeom_CartesianPoint::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Handle(TColStd_HArray1OfReal)& aCoordinates)
+{
+	// --- classe own fields ---
+  nbcoord = aCoordinates->Length();
+  coords[0] = aCoordinates->Value(1);
+  coords[1] = aCoordinates->Value(2);
+  coords[2] = aCoordinates->Value(3);
+//	coordinates = aCoordinates;
+	// --- classe inherited fields ---
+	StepRepr_RepresentationItem::Init(aName);
+}
+
+void StepGeom_CartesianPoint::Init2D(
+	const Handle(TCollection_HAsciiString)& aName,
+        const Standard_Real X, const Standard_Real Y)
+{
+  nbcoord = 2;
+  coords[0] = X;
+  coords[1] = Y;
+	// --- classe inherited fields ---
+	StepRepr_RepresentationItem::Init(aName);
+}
+
+void StepGeom_CartesianPoint::Init3D(
+	const Handle(TCollection_HAsciiString)& aName,
+        const Standard_Real X, const Standard_Real Y, const Standard_Real Z)
+{
+  nbcoord = 3;
+  coords[0] = X;
+  coords[1] = Y;
+  coords[2] = Z;
+	// --- classe inherited fields ---
+	StepRepr_RepresentationItem::Init(aName);
+}
+
+void StepGeom_CartesianPoint::SetCoordinates(const Handle(TColStd_HArray1OfReal)& aCoordinates)
+{
+  nbcoord = aCoordinates->Length();
+  coords[0] = aCoordinates->Value(1);
+  coords[1] = aCoordinates->Value(2);
+  coords[2] = aCoordinates->Value(3);
+//	coordinates = aCoordinates;
+}
+
+Handle(TColStd_HArray1OfReal) StepGeom_CartesianPoint::Coordinates() const
+{
+  Handle(TColStd_HArray1OfReal)  coordinates = new TColStd_HArray1OfReal(1,nbcoord);
+  coordinates->SetValue(1,coords[0]);
+  coordinates->SetValue(2,coords[1]);
+  coordinates->SetValue(3,coords[2]);
+	return coordinates;
+}
+
+Standard_Real StepGeom_CartesianPoint::CoordinatesValue(const Standard_Integer num) const
+{
+  return coords[num-1];
+//	return coordinates->Value(num);
+}
+
+Standard_Integer StepGeom_CartesianPoint::NbCoordinates () const
+{
+  return nbcoord;
+//	return coordinates->Length();
+}

src/StepGeom/StepGeom_CartesianTransformationOperator.cdl

@@ -0,0 +1,67 @@
+-- File:        CartesianTransformationOperator.cdl
+-- Created:     Fri Dec  1 11:11:16 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class CartesianTransformationOperator from StepGeom 
+
+inherits GeometricRepresentationItem from StepGeom 
+-- WARNING : Multiple EXPRESS inheritance
+-- Not yet automaticly managed
+-- inherits FunctionallyDefinedTransformation from StepGeom 
+
+uses
+
+	Direction from StepGeom, 
+	CartesianPoint from StepGeom, 
+	Real from Standard, 
+	Boolean from Standard, 
+	HAsciiString from TCollection
+is
+
+	Create returns mutable CartesianTransformationOperator;
+	---Purpose: Returns a CartesianTransformationOperator
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      hasAaxis1 : Boolean from Standard;
+	      aAxis1 : mutable Direction from StepGeom;
+	      hasAaxis2 : Boolean from Standard;
+	      aAxis2 : mutable Direction from StepGeom;
+	      aLocalOrigin : mutable CartesianPoint from StepGeom;
+	      hasAscale : Boolean from Standard;
+	      aScale : Real from Standard) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetAxis1(me : mutable; aAxis1 : mutable Direction);
+	UnSetAxis1 (me:mutable);
+	Axis1 (me) returns mutable Direction;
+	HasAxis1 (me) returns Boolean;
+	SetAxis2(me : mutable; aAxis2 : mutable Direction);
+	UnSetAxis2 (me:mutable);
+	Axis2 (me) returns mutable Direction;
+	HasAxis2 (me) returns Boolean;
+	SetLocalOrigin(me : mutable; aLocalOrigin : mutable CartesianPoint);
+	LocalOrigin (me) returns mutable CartesianPoint;
+	SetScale(me : mutable; aScale : Real);
+	UnSetScale (me:mutable);
+	Scale (me) returns Real;
+	HasScale (me) returns Boolean;
+
+fields
+
+	axis1 : Direction from StepGeom;   -- OPTIONAL can be NULL
+	axis2 : Direction from StepGeom;   -- OPTIONAL can be NULL
+	localOrigin : CartesianPoint from StepGeom;
+	scale : Real from Standard;   -- OPTIONAL can be NULL
+	hasAxis1 : Boolean from Standard;
+	hasAxis2 : Boolean from Standard;
+	hasScale : Boolean from Standard;
+
+end CartesianTransformationOperator;

src/StepGeom/StepGeom_CartesianTransformationOperator.cxx

@@ -0,0 +1,109 @@
+#include <StepGeom_CartesianTransformationOperator.ixx>
+
+
+StepGeom_CartesianTransformationOperator::StepGeom_CartesianTransformationOperator ()  {}
+
+void StepGeom_CartesianTransformationOperator::Init(
+	const Handle(TCollection_HAsciiString)& aName)
+{
+
+	StepRepr_RepresentationItem::Init(aName);
+}
+
+void StepGeom_CartesianTransformationOperator::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Standard_Boolean hasAaxis1,
+	const Handle(StepGeom_Direction)& aAxis1,
+	const Standard_Boolean hasAaxis2,
+	const Handle(StepGeom_Direction)& aAxis2,
+	const Handle(StepGeom_CartesianPoint)& aLocalOrigin,
+	const Standard_Boolean hasAscale,
+	const Standard_Real aScale)
+{
+	// --- classe own fields ---
+	hasAxis1 = hasAaxis1;
+	axis1 = aAxis1;
+	hasAxis2 = hasAaxis2;
+	axis2 = aAxis2;
+	localOrigin = aLocalOrigin;
+	hasScale = hasAscale;
+	scale = aScale;
+	// --- classe inherited fields ---
+	StepRepr_RepresentationItem::Init(aName);
+}
+
+
+void StepGeom_CartesianTransformationOperator::SetAxis1(const Handle(StepGeom_Direction)& aAxis1)
+{
+	axis1 = aAxis1;
+	hasAxis1 = Standard_True;
+}
+
+void StepGeom_CartesianTransformationOperator::UnSetAxis1()
+{
+	hasAxis1 = Standard_False;
+	axis1.Nullify();
+}
+
+Handle(StepGeom_Direction) StepGeom_CartesianTransformationOperator::Axis1() const
+{
+	return axis1;
+}
+
+Standard_Boolean StepGeom_CartesianTransformationOperator::HasAxis1() const
+{
+	return hasAxis1;
+}
+
+void StepGeom_CartesianTransformationOperator::SetAxis2(const Handle(StepGeom_Direction)& aAxis2)
+{
+	axis2 = aAxis2;
+	hasAxis2 = Standard_True;
+}
+
+void StepGeom_CartesianTransformationOperator::UnSetAxis2()
+{
+	hasAxis2 = Standard_False;
+	axis2.Nullify();
+}
+
+Handle(StepGeom_Direction) StepGeom_CartesianTransformationOperator::Axis2() const
+{
+	return axis2;
+}
+
+Standard_Boolean StepGeom_CartesianTransformationOperator::HasAxis2() const
+{
+	return hasAxis2;
+}
+
+void StepGeom_CartesianTransformationOperator::SetLocalOrigin(const Handle(StepGeom_CartesianPoint)& aLocalOrigin)
+{
+	localOrigin = aLocalOrigin;
+}
+
+Handle(StepGeom_CartesianPoint) StepGeom_CartesianTransformationOperator::LocalOrigin() const
+{
+	return localOrigin;
+}
+
+void StepGeom_CartesianTransformationOperator::SetScale(const Standard_Real aScale)
+{
+	scale = aScale;
+	hasScale = Standard_True;
+}
+
+void StepGeom_CartesianTransformationOperator::UnSetScale()
+{
+	hasScale = Standard_False;
+}
+
+Standard_Real StepGeom_CartesianTransformationOperator::Scale() const
+{
+	return scale;
+}
+
+Standard_Boolean StepGeom_CartesianTransformationOperator::HasScale() const
+{
+	return hasScale;
+}

src/StepGeom/StepGeom_CartesianTransformationOperator2d.cdl

@@ -0,0 +1,20 @@
+-- File:	StepGeom_CartesianTransformationOperator2d.cdl
+-- Created:	Wed Mar 26 15:17:23 1997
+-- Author:	Christian CAILLET
+--		<cky@heliox.paris1.matra-dtv.fr>
+---Copyright:	 Matra Datavision 1997
+
+
+class CartesianTransformationOperator2d  from StepGeom
+
+inherits CartesianTransformationOperator from StepGeom
+
+    ---Purpose : Added from StepGeom Rev2 to Rev4
+
+uses Boolean
+
+is
+
+    Create returns mutable CartesianTransformationOperator2d from StepGeom;
+
+end CartesianTransformationOperator2d;

src/StepGeom/StepGeom_CartesianTransformationOperator2d.cxx

@@ -0,0 +1,3 @@
+#include <StepGeom_CartesianTransformationOperator2d.ixx>
+
+StepGeom_CartesianTransformationOperator2d::StepGeom_CartesianTransformationOperator2d  ()    {  }

src/StepGeom/StepGeom_CartesianTransformationOperator3d.cdl

@@ -0,0 +1,58 @@
+-- File:        CartesianTransformationOperator3d.cdl
+-- Created:     Fri Dec  1 11:11:16 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class CartesianTransformationOperator3d from StepGeom 
+
+inherits CartesianTransformationOperator from StepGeom 
+
+uses
+
+	Direction from StepGeom, 
+	Boolean from Standard, 
+	HAsciiString from TCollection, 
+	CartesianPoint from StepGeom, 
+	Real from Standard
+is
+
+	Create returns mutable CartesianTransformationOperator3d;
+	---Purpose: Returns a CartesianTransformationOperator3d
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      hasAaxis1 : Boolean from Standard;
+	      aAxis1 : mutable Direction from StepGeom;
+	      hasAaxis2 : Boolean from Standard;
+	      aAxis2 : mutable Direction from StepGeom;
+	      aLocalOrigin : mutable CartesianPoint from StepGeom;
+	      hasAscale : Boolean from Standard;
+	      aScale : Real from Standard) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      hasAaxis1 : Boolean from Standard;
+	      aAxis1 : mutable Direction from StepGeom;
+	      hasAaxis2 : Boolean from Standard;
+	      aAxis2 : mutable Direction from StepGeom;
+	      aLocalOrigin : mutable CartesianPoint from StepGeom;
+	      hasAscale : Boolean from Standard;
+	      aScale : Real from Standard;
+	      hasAaxis3 : Boolean from Standard;
+	      aAxis3 : mutable Direction from StepGeom) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetAxis3(me : mutable; aAxis3 : mutable Direction);
+	UnSetAxis3 (me:mutable);
+	Axis3 (me) returns mutable Direction;
+	HasAxis3 (me) returns Boolean;
+
+fields
+
+	axis3 : Direction from StepGeom;   -- OPTIONAL can be NULL
+	hasAxis3 : Boolean from Standard;
+
+end CartesianTransformationOperator3d;

src/StepGeom/StepGeom_CartesianTransformationOperator3d.cxx

@@ -0,0 +1,60 @@
+#include <StepGeom_CartesianTransformationOperator3d.ixx>
+
+
+StepGeom_CartesianTransformationOperator3d::StepGeom_CartesianTransformationOperator3d ()  {}
+
+void StepGeom_CartesianTransformationOperator3d::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Standard_Boolean hasAaxis1,
+	const Handle(StepGeom_Direction)& aAxis1,
+	const Standard_Boolean hasAaxis2,
+	const Handle(StepGeom_Direction)& aAxis2,
+	const Handle(StepGeom_CartesianPoint)& aLocalOrigin,
+	const Standard_Boolean hasAscale,
+	const Standard_Real aScale)
+{
+
+	StepGeom_CartesianTransformationOperator::Init(aName, hasAaxis1, aAxis1, hasAaxis2, aAxis2, aLocalOrigin, hasAscale, aScale);
+}
+
+void StepGeom_CartesianTransformationOperator3d::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Standard_Boolean hasAaxis1,
+	const Handle(StepGeom_Direction)& aAxis1,
+	const Standard_Boolean hasAaxis2,
+	const Handle(StepGeom_Direction)& aAxis2,
+	const Handle(StepGeom_CartesianPoint)& aLocalOrigin,
+	const Standard_Boolean hasAscale,
+	const Standard_Real aScale,
+	const Standard_Boolean hasAaxis3,
+	const Handle(StepGeom_Direction)& aAxis3)
+{
+	// --- classe own fields ---
+	hasAxis3 = hasAaxis3;
+	axis3 = aAxis3;
+	// --- classe inherited fields ---
+	StepGeom_CartesianTransformationOperator::Init(aName, hasAaxis1, aAxis1, hasAaxis2, aAxis2, aLocalOrigin, hasAscale, aScale);
+}
+
+
+void StepGeom_CartesianTransformationOperator3d::SetAxis3(const Handle(StepGeom_Direction)& aAxis3)
+{
+	axis3 = aAxis3;
+	hasAxis3 = Standard_True;
+}
+
+void StepGeom_CartesianTransformationOperator3d::UnSetAxis3()
+{
+	hasAxis3 = Standard_False;
+	axis3.Nullify();
+}
+
+Handle(StepGeom_Direction) StepGeom_CartesianTransformationOperator3d::Axis3() const
+{
+	return axis3;
+}
+
+Standard_Boolean StepGeom_CartesianTransformationOperator3d::HasAxis3() const
+{
+	return hasAxis3;
+}

src/StepGeom/StepGeom_Circle.cdl

@@ -0,0 +1,40 @@
+-- File:        Circle.cdl
+-- Created:     Fri Dec  1 11:11:16 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class Circle from StepGeom 
+
+inherits Conic from StepGeom 
+
+uses
+
+	Real from Standard, 
+	HAsciiString from TCollection, 
+	Axis2Placement from StepGeom
+is
+
+	Create returns mutable Circle;
+	---Purpose: Returns a Circle
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aPosition : Axis2Placement from StepGeom) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aPosition : Axis2Placement from StepGeom;
+	      aRadius : Real from Standard) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetRadius(me : mutable; aRadius : Real);
+	Radius (me) returns Real;
+
+fields
+
+	radius : Real from Standard;
+
+end Circle;

src/StepGeom/StepGeom_Circle.cxx

@@ -0,0 +1,34 @@
+#include <StepGeom_Circle.ixx>
+
+
+StepGeom_Circle::StepGeom_Circle ()  {}
+
+void StepGeom_Circle::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const StepGeom_Axis2Placement& aPosition)
+{
+
+	StepGeom_Conic::Init(aName, aPosition);
+}
+
+void StepGeom_Circle::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const StepGeom_Axis2Placement& aPosition,
+	const Standard_Real aRadius)
+{
+	// --- classe own fields ---
+	radius = aRadius;
+	// --- classe inherited fields ---
+	StepGeom_Conic::Init(aName, aPosition);
+}
+
+
+void StepGeom_Circle::SetRadius(const Standard_Real aRadius)
+{
+	radius = aRadius;
+}
+
+Standard_Real StepGeom_Circle::Radius() const
+{
+	return radius;
+}

src/StepGeom/StepGeom_CompositeCurve.cdl

@@ -0,0 +1,45 @@
+-- File:        CompositeCurve.cdl
+-- Created:     Fri Dec  1 11:11:16 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class CompositeCurve from StepGeom 
+
+inherits BoundedCurve from StepGeom 
+
+uses
+
+	HArray1OfCompositeCurveSegment from StepGeom, 
+	Logical from StepData, 
+	CompositeCurveSegment from StepGeom, 
+	HAsciiString from TCollection
+is
+
+	Create returns mutable CompositeCurve;
+	---Purpose: Returns a CompositeCurve
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aSegments : mutable HArray1OfCompositeCurveSegment from StepGeom;
+	      aSelfIntersect : Logical from StepData) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetSegments(me : mutable; aSegments : mutable HArray1OfCompositeCurveSegment);
+	Segments (me) returns mutable HArray1OfCompositeCurveSegment;
+	SegmentsValue (me; num : Integer) returns mutable CompositeCurveSegment;
+	NbSegments (me) returns Integer;
+	SetSelfIntersect(me : mutable; aSelfIntersect : Logical);
+	SelfIntersect (me) returns Logical;
+
+fields
+
+	segments : HArray1OfCompositeCurveSegment from StepGeom;
+	selfIntersect : Logical from StepData;
+
+end CompositeCurve;

src/StepGeom/StepGeom_CompositeCurve.cxx

@@ -0,0 +1,55 @@
+#include <StepGeom_CompositeCurve.ixx>
+
+
+StepGeom_CompositeCurve::StepGeom_CompositeCurve ()  {}
+
+void StepGeom_CompositeCurve::Init(
+	const Handle(TCollection_HAsciiString)& aName)
+{
+
+	StepRepr_RepresentationItem::Init(aName);
+}
+
+void StepGeom_CompositeCurve::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Handle(StepGeom_HArray1OfCompositeCurveSegment)& aSegments,
+	const StepData_Logical aSelfIntersect)
+{
+	// --- classe own fields ---
+	segments = aSegments;
+	selfIntersect = aSelfIntersect;
+	// --- classe inherited fields ---
+	StepRepr_RepresentationItem::Init(aName);
+}
+
+
+void StepGeom_CompositeCurve::SetSegments(const Handle(StepGeom_HArray1OfCompositeCurveSegment)& aSegments)
+{
+	segments = aSegments;
+}
+
+Handle(StepGeom_HArray1OfCompositeCurveSegment) StepGeom_CompositeCurve::Segments() const
+{
+	return segments;
+}
+
+Handle(StepGeom_CompositeCurveSegment) StepGeom_CompositeCurve::SegmentsValue(const Standard_Integer num) const
+{
+	return segments->Value(num);
+}
+
+Standard_Integer StepGeom_CompositeCurve::NbSegments () const
+{
+	if (segments.IsNull()) return 0;
+	return segments->Length();
+}
+
+void StepGeom_CompositeCurve::SetSelfIntersect(const StepData_Logical aSelfIntersect)
+{
+	selfIntersect = aSelfIntersect;
+}
+
+StepData_Logical StepGeom_CompositeCurve::SelfIntersect() const
+{
+	return selfIntersect;
+}

src/StepGeom/StepGeom_CompositeCurveOnSurface.cdl

@@ -0,0 +1,22 @@
+-- File:        CompositeCurveOnSurface.cdl
+-- Created:     Fri Dec  1 11:11:16 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class CompositeCurveOnSurface from StepGeom 
+
+inherits CompositeCurve from StepGeom 
+
+uses
+
+	HAsciiString from TCollection, 
+	HArray1OfCompositeCurveSegment from StepGeom, 
+	Logical from StepData
+is
+
+	Create returns mutable CompositeCurveOnSurface;
+	---Purpose: Returns a CompositeCurveOnSurface
+
+
+end CompositeCurveOnSurface;

src/StepGeom/StepGeom_CompositeCurveOnSurface.cxx

@@ -0,0 +1,5 @@
+#include <StepGeom_CompositeCurveOnSurface.ixx>
+
+
+StepGeom_CompositeCurveOnSurface::StepGeom_CompositeCurveOnSurface ()  {}
+

src/StepGeom/StepGeom_CompositeCurveSegment.cdl

@@ -0,0 +1,41 @@
+-- File:        CompositeCurveSegment.cdl
+-- Created:     Fri Dec  1 11:11:16 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class CompositeCurveSegment from StepGeom 
+
+inherits TShared from MMgt
+
+uses
+
+	TransitionCode from StepGeom, 
+	Boolean from Standard, 
+	Curve from StepGeom
+is
+
+	Create returns mutable CompositeCurveSegment;
+	---Purpose: Returns a CompositeCurveSegment
+
+	Init (me : mutable;
+	      aTransition : TransitionCode from StepGeom;
+	      aSameSense : Boolean from Standard;
+	      aParentCurve : mutable Curve from StepGeom) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetTransition(me : mutable; aTransition : TransitionCode);
+	Transition (me) returns TransitionCode;
+	SetSameSense(me : mutable; aSameSense : Boolean);
+	SameSense (me) returns Boolean;
+	SetParentCurve(me : mutable; aParentCurve : mutable Curve);
+	ParentCurve (me) returns mutable Curve;
+
+fields
+
+	transition : TransitionCode from StepGeom; -- an Enumeration
+	sameSense : Boolean from Standard;
+	parentCurve : Curve from StepGeom;
+
+end CompositeCurveSegment;

src/StepGeom/StepGeom_CompositeCurveSegment.cxx

@@ -0,0 +1,46 @@
+#include <StepGeom_CompositeCurveSegment.ixx>
+
+
+StepGeom_CompositeCurveSegment::StepGeom_CompositeCurveSegment ()  {}
+
+void StepGeom_CompositeCurveSegment::Init(
+	const StepGeom_TransitionCode aTransition,
+	const Standard_Boolean aSameSense,
+	const Handle(StepGeom_Curve)& aParentCurve)
+{
+	// --- classe own fields ---
+	transition = aTransition;
+	sameSense = aSameSense;
+	parentCurve = aParentCurve;
+}
+
+
+void StepGeom_CompositeCurveSegment::SetTransition(const StepGeom_TransitionCode aTransition)
+{
+	transition = aTransition;
+}
+
+StepGeom_TransitionCode StepGeom_CompositeCurveSegment::Transition() const
+{
+	return transition;
+}
+
+void StepGeom_CompositeCurveSegment::SetSameSense(const Standard_Boolean aSameSense)
+{
+	sameSense = aSameSense;
+}
+
+Standard_Boolean StepGeom_CompositeCurveSegment::SameSense() const
+{
+	return sameSense;
+}
+
+void StepGeom_CompositeCurveSegment::SetParentCurve(const Handle(StepGeom_Curve)& aParentCurve)
+{
+	parentCurve = aParentCurve;
+}
+
+Handle(StepGeom_Curve) StepGeom_CompositeCurveSegment::ParentCurve() const
+{
+	return parentCurve;
+}

src/StepGeom/StepGeom_Conic.cdl

@@ -0,0 +1,37 @@
+-- File:        Conic.cdl
+-- Created:     Fri Dec  1 11:11:17 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class Conic from StepGeom 
+
+inherits Curve from StepGeom 
+
+uses
+
+	Axis2Placement from StepGeom, 
+	HAsciiString from TCollection
+is
+
+	Create returns mutable Conic;
+	---Purpose: Returns a Conic
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aPosition : Axis2Placement from StepGeom) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetPosition(me : mutable; aPosition : Axis2Placement);
+	Position (me) returns Axis2Placement;
+
+fields
+
+	position : Axis2Placement from StepGeom; -- a SelectType
+
+end Conic;

src/StepGeom/StepGeom_Conic.cxx

@@ -0,0 +1,32 @@
+#include <StepGeom_Conic.ixx>
+
+
+StepGeom_Conic::StepGeom_Conic ()  {}
+
+void StepGeom_Conic::Init(
+	const Handle(TCollection_HAsciiString)& aName)
+{
+
+	StepRepr_RepresentationItem::Init(aName);
+}
+
+void StepGeom_Conic::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const StepGeom_Axis2Placement& aPosition)
+{
+	// --- classe own fields ---
+	position = aPosition;
+	// --- classe inherited fields ---
+	StepRepr_RepresentationItem::Init(aName);
+}
+
+
+void StepGeom_Conic::SetPosition(const StepGeom_Axis2Placement& aPosition)
+{
+	position = aPosition;
+}
+
+StepGeom_Axis2Placement StepGeom_Conic::Position() const
+{
+	return position;
+}

src/StepGeom/StepGeom_ConicalSurface.cdl

@@ -0,0 +1,44 @@
+-- File:        ConicalSurface.cdl
+-- Created:     Fri Dec  1 11:11:17 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class ConicalSurface from StepGeom 
+
+inherits ElementarySurface from StepGeom 
+
+uses
+
+	Real from Standard, 
+	HAsciiString from TCollection, 
+	Axis2Placement3d from StepGeom
+is
+
+	Create returns mutable ConicalSurface;
+	---Purpose: Returns a ConicalSurface
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aPosition : mutable Axis2Placement3d from StepGeom) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aPosition : mutable Axis2Placement3d from StepGeom;
+	      aRadius : Real from Standard;
+	      aSemiAngle : Real from Standard) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetRadius(me : mutable; aRadius : Real);
+	Radius (me) returns Real;
+	SetSemiAngle(me : mutable; aSemiAngle : Real);
+	SemiAngle (me) returns Real;
+
+fields
+
+	radius : Real from Standard;
+	semiAngle : Real from Standard;
+
+end ConicalSurface;

src/StepGeom/StepGeom_ConicalSurface.cxx

@@ -0,0 +1,46 @@
+#include <StepGeom_ConicalSurface.ixx>
+
+
+StepGeom_ConicalSurface::StepGeom_ConicalSurface ()  {}
+
+void StepGeom_ConicalSurface::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Handle(StepGeom_Axis2Placement3d)& aPosition)
+{
+
+	StepGeom_ElementarySurface::Init(aName, aPosition);
+}
+
+void StepGeom_ConicalSurface::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Handle(StepGeom_Axis2Placement3d)& aPosition,
+	const Standard_Real aRadius,
+	const Standard_Real aSemiAngle)
+{
+	// --- classe own fields ---
+	radius = aRadius;
+	semiAngle = aSemiAngle;
+	// --- classe inherited fields ---
+	StepGeom_ElementarySurface::Init(aName, aPosition);
+}
+
+
+void StepGeom_ConicalSurface::SetRadius(const Standard_Real aRadius)
+{
+	radius = aRadius;
+}
+
+Standard_Real StepGeom_ConicalSurface::Radius() const
+{
+	return radius;
+}
+
+void StepGeom_ConicalSurface::SetSemiAngle(const Standard_Real aSemiAngle)
+{
+	semiAngle = aSemiAngle;
+}
+
+Standard_Real StepGeom_ConicalSurface::SemiAngle() const
+{
+	return semiAngle;
+}

src/StepGeom/StepGeom_Curve.cdl

@@ -0,0 +1,20 @@
+-- File:        Curve.cdl
+-- Created:     Fri Dec  1 11:11:17 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class Curve from StepGeom 
+
+inherits GeometricRepresentationItem from StepGeom 
+
+uses
+
+	HAsciiString from TCollection
+is
+
+	Create returns mutable Curve;
+	---Purpose: Returns a Curve
+
+
+end Curve;

src/StepGeom/StepGeom_Curve.cxx

@@ -0,0 +1,5 @@
+#include <StepGeom_Curve.ixx>
+
+
+StepGeom_Curve::StepGeom_Curve ()  {}
+

src/StepGeom/StepGeom_CurveBoundedSurface.cdl

@@ -0,0 +1,47 @@
+-- File:	StepGeom_CurveBoundedSurface.cdl
+-- Created:	Fri Nov 26 16:26:38 1999 
+-- Author:	Andrey BETENEV
+-- Generator:	ExpToCas (EXPRESS -> CASCADE/XSTEP Translator) V1.0
+-- Copyright:	Matra Datavision 1999
+
+class CurveBoundedSurface from StepGeom
+inherits BoundedSurface from StepGeom
+
+    ---Purpose: Representation of STEP entity CurveBoundedSurface
+
+uses
+    HAsciiString from TCollection,
+    Surface from StepGeom,
+    HArray1OfSurfaceBoundary from StepGeom
+
+is
+    Create returns CurveBoundedSurface from StepGeom;
+	---Purpose: Empty constructor
+
+    Init (me: mutable; aRepresentationItem_Name: HAsciiString from TCollection;
+                       aBasisSurface: Surface from StepGeom;
+                       aBoundaries: HArray1OfSurfaceBoundary from StepGeom;
+                       aImplicitOuter: Boolean);
+	---Purpose: Initialize all fields (own and inherited)
+
+    BasisSurface (me) returns Surface from StepGeom;
+	---Purpose: Returns field BasisSurface
+    SetBasisSurface (me: mutable; BasisSurface: Surface from StepGeom);
+	---Purpose: Set field BasisSurface
+
+    Boundaries (me) returns HArray1OfSurfaceBoundary from StepGeom;
+	---Purpose: Returns field Boundaries
+    SetBoundaries (me: mutable; Boundaries: HArray1OfSurfaceBoundary from StepGeom);
+	---Purpose: Set field Boundaries
+
+    ImplicitOuter (me) returns Boolean;
+	---Purpose: Returns field ImplicitOuter
+    SetImplicitOuter (me: mutable; ImplicitOuter: Boolean);
+	---Purpose: Set field ImplicitOuter
+
+fields
+    theBasisSurface: Surface from StepGeom;
+    theBoundaries: HArray1OfSurfaceBoundary from StepGeom;
+    theImplicitOuter: Boolean;
+
+end CurveBoundedSurface;

src/StepGeom/StepGeom_CurveBoundedSurface.cxx

@@ -0,0 +1,95 @@
+// File:	StepGeom_CurveBoundedSurface.cxx
+// Created:	Fri Nov 26 16:26:38 1999 
+// Author:	Andrey BETENEV
+// Generator:	ExpToCas (EXPRESS -> CASCADE/XSTEP Translator) V1.0
+// Copyright:	Matra Datavision 1999
+
+#include <StepGeom_CurveBoundedSurface.ixx>
+
+//=======================================================================
+//function : StepGeom_CurveBoundedSurface
+//purpose  : 
+//=======================================================================
+
+StepGeom_CurveBoundedSurface::StepGeom_CurveBoundedSurface ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose  : 
+//=======================================================================
+
+void StepGeom_CurveBoundedSurface::Init (const Handle(TCollection_HAsciiString) &aRepresentationItem_Name,
+                                         const Handle(StepGeom_Surface) &aBasisSurface,
+                                         const Handle(StepGeom_HArray1OfSurfaceBoundary) &aBoundaries,
+                                         const Standard_Boolean aImplicitOuter)
+{
+  StepGeom_BoundedSurface::Init(aRepresentationItem_Name);
+
+  theBasisSurface = aBasisSurface;
+
+  theBoundaries = aBoundaries;
+
+  theImplicitOuter = aImplicitOuter;
+}
+
+//=======================================================================
+//function : BasisSurface
+//purpose  : 
+//=======================================================================
+
+Handle(StepGeom_Surface) StepGeom_CurveBoundedSurface::BasisSurface () const
+{
+  return theBasisSurface;
+}
+
+//=======================================================================
+//function : SetBasisSurface
+//purpose  : 
+//=======================================================================
+
+void StepGeom_CurveBoundedSurface::SetBasisSurface (const Handle(StepGeom_Surface) &aBasisSurface)
+{
+  theBasisSurface = aBasisSurface;
+}
+
+//=======================================================================
+//function : Boundaries
+//purpose  : 
+//=======================================================================
+
+Handle(StepGeom_HArray1OfSurfaceBoundary) StepGeom_CurveBoundedSurface::Boundaries () const
+{
+  return theBoundaries;
+}
+
+//=======================================================================
+//function : SetBoundaries
+//purpose  : 
+//=======================================================================
+
+void StepGeom_CurveBoundedSurface::SetBoundaries (const Handle(StepGeom_HArray1OfSurfaceBoundary) &aBoundaries)
+{
+  theBoundaries = aBoundaries;
+}
+
+//=======================================================================
+//function : ImplicitOuter
+//purpose  : 
+//=======================================================================
+
+Standard_Boolean StepGeom_CurveBoundedSurface::ImplicitOuter () const
+{
+  return theImplicitOuter;
+}
+
+//=======================================================================
+//function : SetImplicitOuter
+//purpose  : 
+//=======================================================================
+
+void StepGeom_CurveBoundedSurface::SetImplicitOuter (const Standard_Boolean aImplicitOuter)
+{
+  theImplicitOuter = aImplicitOuter;
+}

src/StepGeom/StepGeom_CurveOnSurface.cdl

@@ -0,0 +1,41 @@
+-- File:        CurveOnSurface.cdl
+-- Created:     Fri Dec  1 11:11:10 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+
+class CurveOnSurface from StepGeom inherits SelectType from StepData
+
+	-- <CurveOnSurface> is an EXPRESS Select Type construct translation.
+	-- it gathers : Pcurve, SurfaceCurve, CompositeCurveOnSurface
+
+uses
+
+	Pcurve,
+	SurfaceCurve,
+	CompositeCurveOnSurface
+is
+
+	Create returns CurveOnSurface;
+	---Purpose : Returns a CurveOnSurface SelectType
+
+	CaseNum (me; ent : Transient) returns Integer;
+	---Purpose: Recognizes a CurveOnSurface Kind Entity that is :
+	--        1 -> Pcurve
+	--        2 -> SurfaceCurve
+	--        3 -> CompositeCurveOnSurface
+	--        0 else
+
+	Pcurve (me) returns any Pcurve;
+	---Purpose : returns Value as a Pcurve (Null if another type)
+
+	SurfaceCurve (me) returns any SurfaceCurve;
+	---Purpose : returns Value as a SurfaceCurve (Null if another type)
+
+	CompositeCurveOnSurface (me) returns any CompositeCurveOnSurface;
+	---Purpose : returns Value as a CompositeCurveOnSurface (Null if another type)
+
+
+end CurveOnSurface;
+

src/StepGeom/StepGeom_CurveOnSurface.cxx

@@ -0,0 +1,29 @@
+
+#include <StepGeom_CurveOnSurface.ixx>
+#include <Interface_Macros.hxx>
+
+StepGeom_CurveOnSurface::StepGeom_CurveOnSurface () {  }
+
+Standard_Integer StepGeom_CurveOnSurface::CaseNum(const Handle(Standard_Transient)& ent) const
+{
+	if (ent.IsNull()) return 0;
+	if (ent->IsKind(STANDARD_TYPE(StepGeom_Pcurve))) return 1;
+	if (ent->IsKind(STANDARD_TYPE(StepGeom_SurfaceCurve))) return 2;
+	if (ent->IsKind(STANDARD_TYPE(StepGeom_CompositeCurveOnSurface))) return 3;
+	return 0;
+}
+
+Handle(StepGeom_Pcurve) StepGeom_CurveOnSurface::Pcurve () const
+{
+	return GetCasted(StepGeom_Pcurve,Value());
+}
+
+Handle(StepGeom_SurfaceCurve) StepGeom_CurveOnSurface::SurfaceCurve () const
+{
+	return GetCasted(StepGeom_SurfaceCurve,Value());
+}
+
+Handle(StepGeom_CompositeCurveOnSurface) StepGeom_CurveOnSurface::CompositeCurveOnSurface () const
+{
+	return GetCasted(StepGeom_CompositeCurveOnSurface,Value());
+}

src/StepGeom/StepGeom_CurveReplica.cdl

@@ -0,0 +1,41 @@
+-- File:        CurveReplica.cdl
+-- Created:     Fri Dec  1 11:11:17 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class CurveReplica from StepGeom 
+
+inherits Curve from StepGeom 
+
+uses
+
+	CartesianTransformationOperator from StepGeom, 
+	HAsciiString from TCollection
+is
+
+	Create returns mutable CurveReplica;
+	---Purpose: Returns a CurveReplica
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aParentCurve : mutable Curve from StepGeom;
+	      aTransformation : mutable CartesianTransformationOperator from StepGeom) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetParentCurve(me : mutable; aParentCurve : mutable Curve);
+	ParentCurve (me) returns mutable Curve;
+	SetTransformation(me : mutable; aTransformation : mutable CartesianTransformationOperator);
+	Transformation (me) returns mutable CartesianTransformationOperator;
+
+fields
+
+	parentCurve : Curve from StepGeom;
+	transformation : CartesianTransformationOperator from StepGeom;
+
+end CurveReplica;

src/StepGeom/StepGeom_CurveReplica.cxx

@@ -0,0 +1,44 @@
+#include <StepGeom_CurveReplica.ixx>
+
+
+StepGeom_CurveReplica::StepGeom_CurveReplica ()  {}
+
+void StepGeom_CurveReplica::Init(
+	const Handle(TCollection_HAsciiString)& aName)
+{
+
+	StepRepr_RepresentationItem::Init(aName);
+}
+
+void StepGeom_CurveReplica::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Handle(StepGeom_Curve)& aParentCurve,
+	const Handle(StepGeom_CartesianTransformationOperator)& aTransformation)
+{
+	// --- classe own fields ---
+	parentCurve = aParentCurve;
+	transformation = aTransformation;
+	// --- classe inherited fields ---
+	StepRepr_RepresentationItem::Init(aName);
+}
+
+
+void StepGeom_CurveReplica::SetParentCurve(const Handle(StepGeom_Curve)& aParentCurve)
+{
+	parentCurve = aParentCurve;
+}
+
+Handle(StepGeom_Curve) StepGeom_CurveReplica::ParentCurve() const
+{
+	return parentCurve;
+}
+
+void StepGeom_CurveReplica::SetTransformation(const Handle(StepGeom_CartesianTransformationOperator)& aTransformation)
+{
+	transformation = aTransformation;
+}
+
+Handle(StepGeom_CartesianTransformationOperator) StepGeom_CurveReplica::Transformation() const
+{
+	return transformation;
+}

src/StepGeom/StepGeom_CylindricalSurface.cdl

@@ -0,0 +1,40 @@
+-- File:        CylindricalSurface.cdl
+-- Created:     Fri Dec  1 11:11:17 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class CylindricalSurface from StepGeom 
+
+inherits ElementarySurface from StepGeom 
+
+uses
+
+	Real from Standard, 
+	HAsciiString from TCollection, 
+	Axis2Placement3d from StepGeom
+is
+
+	Create returns mutable CylindricalSurface;
+	---Purpose: Returns a CylindricalSurface
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aPosition : mutable Axis2Placement3d from StepGeom) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aPosition : mutable Axis2Placement3d from StepGeom;
+	      aRadius : Real from Standard) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetRadius(me : mutable; aRadius : Real);
+	Radius (me) returns Real;
+
+fields
+
+	radius : Real from Standard;
+
+end CylindricalSurface;

src/StepGeom/StepGeom_CylindricalSurface.cxx

@@ -0,0 +1,34 @@
+#include <StepGeom_CylindricalSurface.ixx>
+
+
+StepGeom_CylindricalSurface::StepGeom_CylindricalSurface ()  {}
+
+void StepGeom_CylindricalSurface::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Handle(StepGeom_Axis2Placement3d)& aPosition)
+{
+
+	StepGeom_ElementarySurface::Init(aName, aPosition);
+}
+
+void StepGeom_CylindricalSurface::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Handle(StepGeom_Axis2Placement3d)& aPosition,
+	const Standard_Real aRadius)
+{
+	// --- classe own fields ---
+	radius = aRadius;
+	// --- classe inherited fields ---
+	StepGeom_ElementarySurface::Init(aName, aPosition);
+}
+
+
+void StepGeom_CylindricalSurface::SetRadius(const Standard_Real aRadius)
+{
+	radius = aRadius;
+}
+
+Standard_Real StepGeom_CylindricalSurface::Radius() const
+{
+	return radius;
+}

src/StepGeom/StepGeom_DegeneratePcurve.cdl

@@ -0,0 +1,42 @@
+-- File:        DegeneratePcurve.cdl
+-- Created:     Fri Dec  1 11:11:18 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class DegeneratePcurve from StepGeom 
+
+inherits Point from StepGeom 
+
+uses
+
+	Surface from StepGeom, 
+	DefinitionalRepresentation from StepRepr,
+	HAsciiString from TCollection
+is
+
+	Create returns mutable DegeneratePcurve;
+	---Purpose: Returns a DegeneratePcurve
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aBasisSurface : mutable Surface from StepGeom;
+	      aReferenceToCurve : mutable DefinitionalRepresentation from StepRepr) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetBasisSurface(me : mutable; aBasisSurface : mutable Surface);
+	BasisSurface (me) returns mutable Surface;
+	SetReferenceToCurve(me : mutable; aReferenceToCurve : mutable DefinitionalRepresentation);
+	ReferenceToCurve (me) returns mutable DefinitionalRepresentation;
+
+fields
+
+	basisSurface : Surface from StepGeom;
+	referenceToCurve : DefinitionalRepresentation from StepRepr;
+
+end DegeneratePcurve;

src/StepGeom/StepGeom_DegeneratePcurve.cxx

@@ -0,0 +1,44 @@
+#include <StepGeom_DegeneratePcurve.ixx>
+
+
+StepGeom_DegeneratePcurve::StepGeom_DegeneratePcurve ()  {}
+
+void StepGeom_DegeneratePcurve::Init(
+	const Handle(TCollection_HAsciiString)& aName)
+{
+
+	StepRepr_RepresentationItem::Init(aName);
+}
+
+void StepGeom_DegeneratePcurve::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Handle(StepGeom_Surface)& aBasisSurface,
+	const Handle(StepRepr_DefinitionalRepresentation)& aReferenceToCurve)
+{
+	// --- classe own fields ---
+	basisSurface = aBasisSurface;
+	referenceToCurve = aReferenceToCurve;
+	// --- classe inherited fields ---
+	StepRepr_RepresentationItem::Init(aName);
+}
+
+
+void StepGeom_DegeneratePcurve::SetBasisSurface(const Handle(StepGeom_Surface)& aBasisSurface)
+{
+	basisSurface = aBasisSurface;
+}
+
+Handle(StepGeom_Surface) StepGeom_DegeneratePcurve::BasisSurface() const
+{
+	return basisSurface;
+}
+
+void StepGeom_DegeneratePcurve::SetReferenceToCurve(const Handle(StepRepr_DefinitionalRepresentation)& aReferenceToCurve)
+{
+	referenceToCurve = aReferenceToCurve;
+}
+
+Handle(StepRepr_DefinitionalRepresentation) StepGeom_DegeneratePcurve::ReferenceToCurve() const
+{
+	return referenceToCurve;
+}

src/StepGeom/StepGeom_DegenerateToroidalSurface.cdl

@@ -0,0 +1,45 @@
+-- File:        DegenerateToroidalSurface.cdl
+-- Created:     Fri Dec  1 11:11:18 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class DegenerateToroidalSurface from StepGeom 
+
+inherits ToroidalSurface from StepGeom 
+
+uses
+
+	Boolean from Standard, 
+	HAsciiString from TCollection, 
+	Axis2Placement3d from StepGeom, 
+	Real from Standard
+is
+
+	Create returns mutable DegenerateToroidalSurface;
+	---Purpose: Returns a DegenerateToroidalSurface
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aPosition : mutable Axis2Placement3d from StepGeom;
+	      aMajorRadius : Real from Standard;
+	      aMinorRadius : Real from Standard) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aPosition : mutable Axis2Placement3d from StepGeom;
+	      aMajorRadius : Real from Standard;
+	      aMinorRadius : Real from Standard;
+	      aSelectOuter : Boolean from Standard) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetSelectOuter(me : mutable; aSelectOuter : Boolean);
+	SelectOuter (me) returns Boolean;
+
+fields
+
+	selectOuter : Boolean from Standard;
+
+end DegenerateToroidalSurface;

src/StepGeom/StepGeom_DegenerateToroidalSurface.cxx

@@ -0,0 +1,38 @@
+#include <StepGeom_DegenerateToroidalSurface.ixx>
+
+
+StepGeom_DegenerateToroidalSurface::StepGeom_DegenerateToroidalSurface ()  {}
+
+void StepGeom_DegenerateToroidalSurface::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Handle(StepGeom_Axis2Placement3d)& aPosition,
+	const Standard_Real aMajorRadius,
+	const Standard_Real aMinorRadius)
+{
+
+	StepGeom_ToroidalSurface::Init(aName, aPosition, aMajorRadius, aMinorRadius);
+}
+
+void StepGeom_DegenerateToroidalSurface::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Handle(StepGeom_Axis2Placement3d)& aPosition,
+	const Standard_Real aMajorRadius,
+	const Standard_Real aMinorRadius,
+	const Standard_Boolean aSelectOuter)
+{
+	// --- classe own fields ---
+	selectOuter = aSelectOuter;
+	// --- classe inherited fields ---
+	StepGeom_ToroidalSurface::Init(aName, aPosition, aMajorRadius, aMinorRadius);
+}
+
+
+void StepGeom_DegenerateToroidalSurface::SetSelectOuter(const Standard_Boolean aSelectOuter)
+{
+	selectOuter = aSelectOuter;
+}
+
+Standard_Boolean StepGeom_DegenerateToroidalSurface::SelectOuter() const
+{
+	return selectOuter;
+}

src/StepGeom/StepGeom_Direction.cdl

@@ -0,0 +1,40 @@
+-- File:        Direction.cdl
+-- Created:     Fri Dec  1 11:11:19 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class Direction from StepGeom 
+
+inherits GeometricRepresentationItem from StepGeom 
+
+uses
+
+	HArray1OfReal from TColStd, 
+	Real from Standard, 
+	HAsciiString from TCollection
+is
+
+	Create returns mutable Direction;
+	---Purpose: Returns a Direction
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aDirectionRatios : mutable HArray1OfReal from TColStd) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetDirectionRatios(me : mutable; aDirectionRatios : mutable HArray1OfReal);
+	DirectionRatios (me) returns mutable HArray1OfReal;
+	DirectionRatiosValue (me; num : Integer) returns Real;
+	NbDirectionRatios (me) returns Integer;
+
+fields
+
+	directionRatios : HArray1OfReal from TColStd;
+
+end Direction;

src/StepGeom/StepGeom_Direction.cxx

@@ -0,0 +1,42 @@
+#include <StepGeom_Direction.ixx>
+
+
+StepGeom_Direction::StepGeom_Direction ()  {}
+
+void StepGeom_Direction::Init(
+	const Handle(TCollection_HAsciiString)& aName)
+{
+
+	StepRepr_RepresentationItem::Init(aName);
+}
+
+void StepGeom_Direction::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Handle(TColStd_HArray1OfReal)& aDirectionRatios)
+{
+	// --- classe own fields ---
+	directionRatios = aDirectionRatios;
+	// --- classe inherited fields ---
+	StepRepr_RepresentationItem::Init(aName);
+}
+
+
+void StepGeom_Direction::SetDirectionRatios(const Handle(TColStd_HArray1OfReal)& aDirectionRatios)
+{
+	directionRatios = aDirectionRatios;
+}
+
+Handle(TColStd_HArray1OfReal) StepGeom_Direction::DirectionRatios() const
+{
+	return directionRatios;
+}
+
+Standard_Real StepGeom_Direction::DirectionRatiosValue(const Standard_Integer num) const
+{
+	return directionRatios->Value(num);
+}
+
+Standard_Integer StepGeom_Direction::NbDirectionRatios () const
+{
+	return directionRatios->Length();
+}

src/StepGeom/StepGeom_ElementarySurface.cdl

@@ -0,0 +1,37 @@
+-- File:        ElementarySurface.cdl
+-- Created:     Fri Dec  1 11:11:19 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class ElementarySurface from StepGeom 
+
+inherits Surface from StepGeom 
+
+uses
+
+	Axis2Placement3d from StepGeom, 
+	HAsciiString from TCollection
+is
+
+	Create returns mutable ElementarySurface;
+	---Purpose: Returns a ElementarySurface
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aPosition : mutable Axis2Placement3d from StepGeom) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetPosition(me : mutable; aPosition : mutable Axis2Placement3d);
+	Position (me) returns mutable Axis2Placement3d;
+
+fields
+
+	position : Axis2Placement3d from StepGeom;
+
+end ElementarySurface;

src/StepGeom/StepGeom_ElementarySurface.cxx

@@ -0,0 +1,32 @@
+#include <StepGeom_ElementarySurface.ixx>
+
+
+StepGeom_ElementarySurface::StepGeom_ElementarySurface ()  {}
+
+void StepGeom_ElementarySurface::Init(
+	const Handle(TCollection_HAsciiString)& aName)
+{
+
+	StepRepr_RepresentationItem::Init(aName);
+}
+
+void StepGeom_ElementarySurface::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Handle(StepGeom_Axis2Placement3d)& aPosition)
+{
+	// --- classe own fields ---
+	position = aPosition;
+	// --- classe inherited fields ---
+	StepRepr_RepresentationItem::Init(aName);
+}
+
+
+void StepGeom_ElementarySurface::SetPosition(const Handle(StepGeom_Axis2Placement3d)& aPosition)
+{
+	position = aPosition;
+}
+
+Handle(StepGeom_Axis2Placement3d) StepGeom_ElementarySurface::Position() const
+{
+	return position;
+}

src/StepGeom/StepGeom_Ellipse.cdl

@@ -0,0 +1,44 @@
+-- File:        Ellipse.cdl
+-- Created:     Fri Dec  1 11:11:19 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class Ellipse from StepGeom 
+
+inherits Conic from StepGeom 
+
+uses
+
+	Real from Standard, 
+	HAsciiString from TCollection, 
+	Axis2Placement from StepGeom
+is
+
+	Create returns mutable Ellipse;
+	---Purpose: Returns a Ellipse
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aPosition : Axis2Placement from StepGeom) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aPosition : Axis2Placement from StepGeom;
+	      aSemiAxis1 : Real from Standard;
+	      aSemiAxis2 : Real from Standard) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetSemiAxis1(me : mutable; aSemiAxis1 : Real);
+	SemiAxis1 (me) returns Real;
+	SetSemiAxis2(me : mutable; aSemiAxis2 : Real);
+	SemiAxis2 (me) returns Real;
+
+fields
+
+	semiAxis1 : Real from Standard;
+	semiAxis2 : Real from Standard;
+
+end Ellipse;

src/StepGeom/StepGeom_Ellipse.cxx

@@ -0,0 +1,46 @@
+#include <StepGeom_Ellipse.ixx>
+
+
+StepGeom_Ellipse::StepGeom_Ellipse ()  {}
+
+void StepGeom_Ellipse::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const StepGeom_Axis2Placement& aPosition)
+{
+
+	StepGeom_Conic::Init(aName, aPosition);
+}
+
+void StepGeom_Ellipse::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const StepGeom_Axis2Placement& aPosition,
+	const Standard_Real aSemiAxis1,
+	const Standard_Real aSemiAxis2)
+{
+	// --- classe own fields ---
+	semiAxis1 = aSemiAxis1;
+	semiAxis2 = aSemiAxis2;
+	// --- classe inherited fields ---
+	StepGeom_Conic::Init(aName, aPosition);
+}
+
+
+void StepGeom_Ellipse::SetSemiAxis1(const Standard_Real aSemiAxis1)
+{
+	semiAxis1 = aSemiAxis1;
+}
+
+Standard_Real StepGeom_Ellipse::SemiAxis1() const
+{
+	return semiAxis1;
+}
+
+void StepGeom_Ellipse::SetSemiAxis2(const Standard_Real aSemiAxis2)
+{
+	semiAxis2 = aSemiAxis2;
+}
+
+Standard_Real StepGeom_Ellipse::SemiAxis2() const
+{
+	return semiAxis2;
+}

src/StepGeom/StepGeom_EvaluatedDegeneratePcurve.cdl

@@ -0,0 +1,43 @@
+-- File:        EvaluatedDegeneratePcurve.cdl
+-- Created:     Fri Dec  1 11:11:19 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class EvaluatedDegeneratePcurve from StepGeom 
+
+inherits DegeneratePcurve from StepGeom 
+
+uses
+
+	CartesianPoint from StepGeom, 
+	HAsciiString from TCollection, 
+	Surface from StepGeom, 
+	DefinitionalRepresentation from StepRepr
+is
+
+	Create returns mutable EvaluatedDegeneratePcurve;
+	---Purpose: Returns a EvaluatedDegeneratePcurve
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aBasisSurface : mutable Surface from StepGeom;
+	      aReferenceToCurve : mutable DefinitionalRepresentation from StepRepr) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aBasisSurface : mutable Surface from StepGeom;
+	      aReferenceToCurve : mutable DefinitionalRepresentation from StepRepr;
+	      aEquivalentPoint : mutable CartesianPoint from StepGeom) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetEquivalentPoint(me : mutable; aEquivalentPoint : mutable CartesianPoint);
+	EquivalentPoint (me) returns mutable CartesianPoint;
+
+fields
+
+	equivalentPoint : CartesianPoint from StepGeom;
+
+end EvaluatedDegeneratePcurve;

src/StepGeom/StepGeom_EvaluatedDegeneratePcurve.cxx

@@ -0,0 +1,36 @@
+#include <StepGeom_EvaluatedDegeneratePcurve.ixx>
+
+
+StepGeom_EvaluatedDegeneratePcurve::StepGeom_EvaluatedDegeneratePcurve ()  {}
+
+void StepGeom_EvaluatedDegeneratePcurve::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Handle(StepGeom_Surface)& aBasisSurface,
+	const Handle(StepRepr_DefinitionalRepresentation)& aReferenceToCurve)
+{
+
+	StepGeom_DegeneratePcurve::Init(aName, aBasisSurface, aReferenceToCurve);
+}
+
+void StepGeom_EvaluatedDegeneratePcurve::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Handle(StepGeom_Surface)& aBasisSurface,
+	const Handle(StepRepr_DefinitionalRepresentation)& aReferenceToCurve,
+	const Handle(StepGeom_CartesianPoint)& aEquivalentPoint)
+{
+	// --- classe own fields ---
+	equivalentPoint = aEquivalentPoint;
+	// --- classe inherited fields ---
+	StepGeom_DegeneratePcurve::Init(aName, aBasisSurface, aReferenceToCurve);
+}
+
+
+void StepGeom_EvaluatedDegeneratePcurve::SetEquivalentPoint(const Handle(StepGeom_CartesianPoint)& aEquivalentPoint)
+{
+	equivalentPoint = aEquivalentPoint;
+}
+
+Handle(StepGeom_CartesianPoint) StepGeom_EvaluatedDegeneratePcurve::EquivalentPoint() const
+{
+	return equivalentPoint;
+}

src/StepGeom/StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx.cdl

@@ -0,0 +1,111 @@
+-- File:	StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx.cdl
+-- Created:	Thu Dec  7 14:45:21 1995
+-- Author:	Frederic MAUPAS
+--		<fma@pronox>
+---Copyright:	 Matra Datavision 1995
+
+class GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx from StepGeom 
+
+    inherits RepresentationContext from StepRepr
+
+    -- This is a hand made implementation of EXPRESS ANDOR construct
+    -- It gather 3 Types :
+    -- 	      GeometricRepresentationContext
+    -- 	      GlobalUnitAssignedContext
+    -- 	      GlobalUncertaintyAssignedContext
+    -- Common Supertype is RepresentationContext
+
+uses 
+
+    GeometricRepresentationContext      from StepGeom,
+    GlobalUnitAssignedContext           from StepRepr,
+    GlobalUncertaintyAssignedContext    from StepRepr,
+    HArray1OfUncertaintyMeasureWithUnit from StepBasic,
+    UncertaintyMeasureWithUnit          from StepBasic,
+    HArray1OfNamedUnit                  from StepBasic, 
+    NamedUnit                           from StepBasic,
+    HAsciiString                        from TCollection, 
+    Integer                             from Standard 
+
+
+is
+
+    Create returns mutable GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx;
+    
+    Init (me : mutable;
+          aContextIdentifier : mutable HAsciiString from TCollection;
+          aContextType : mutable HAsciiString from TCollection) is redefined;
+
+    Init(me : mutable;
+         aContextIdentifier            : mutable HAsciiString                     from TCollection;
+	 aContextType                  : mutable HAsciiString                     from TCollection;
+	 aGeometricRepresentationCtx   : mutable GeometricRepresentationContext   from StepGeom;
+	 aGlobalUnitAssignedCtx        : mutable GlobalUnitAssignedContext        from StepRepr;
+    	 aGlobalUncertaintyAssignedCtx : mutable GlobalUncertaintyAssignedContext from StepRepr)
+    is virtual;
+
+    Init(me : mutable;
+	 aContextIdentifier        : mutable HAsciiString                        from TCollection;
+	 aContextType              : mutable HAsciiString                        from TCollection;
+	 aCoordinateSpaceDimension : Integer                                     from Standard;
+	 aUnits                    : mutable HArray1OfNamedUnit                  from StepBasic;
+	 anUncertainty             : mutable HArray1OfUncertaintyMeasureWithUnit from StepBasic) 
+    is virtual;
+
+    -- ====================================== --
+    -- Specific Methods for Field Data Access --
+    -- ====================================== --
+
+    SetGeometricRepresentationContext
+    	(me : mutable; 
+    	 aGeometricRepresentationContext : mutable GeometricRepresentationContext);
+
+    GeometricRepresentationContext (me) 
+    returns mutable GeometricRepresentationContext;
+
+    SetGlobalUnitAssignedContext
+    	(me : mutable; 
+    	 aGlobalUnitAssignedContext : mutable GlobalUnitAssignedContext);
+
+    GlobalUnitAssignedContext (me) 
+    returns mutable GlobalUnitAssignedContext;
+
+    SetGlobalUncertaintyAssignedContext
+    	(me : mutable;
+    	 aGlobalUncertaintyAssignedCtx : GlobalUncertaintyAssignedContext from StepRepr);
+	 
+    GlobalUncertaintyAssignedContext(me)
+    returns GlobalUncertaintyAssignedContext from StepRepr;
+    
+    -- ============================================================================= --
+    -- Specific Methods for ANDOR Field Data Access : GeometricRepresentationContext --
+    -- ============================================================================= --
+    
+    SetCoordinateSpaceDimension(me : mutable; aCoordinateSpaceDimension : Integer);
+    CoordinateSpaceDimension (me) returns Integer;
+
+    -- ====================================================================== --
+    -- Specific Methods for ANDOR Field Data Access GlobalUnitAssignedContext --
+    -- ====================================================================== --
+
+    SetUnits(me : mutable; aUnits : mutable HArray1OfNamedUnit);
+    Units (me) returns mutable HArray1OfNamedUnit;
+    UnitsValue (me; num : Integer) returns mutable NamedUnit;
+    NbUnits (me) returns Integer;
+	
+    -- ============================================================================= --
+    -- Specific Methods for ANDOR Field Data Access GlobalUncertaintyAssignedContext --
+    -- ============================================================================= --
+
+    SetUncertainty(me : mutable; aUncertainty : mutable HArray1OfUncertaintyMeasureWithUnit);
+    Uncertainty (me) returns mutable HArray1OfUncertaintyMeasureWithUnit;
+    UncertaintyValue (me; num : Integer) returns mutable UncertaintyMeasureWithUnit;
+    NbUncertainty (me) returns Integer;
+
+fields
+
+    geometricRepresentationContext   : GeometricRepresentationContext   from StepGeom;
+    globalUnitAssignedContext        : GlobalUnitAssignedContext        from StepRepr;
+    globalUncertaintyAssignedContext : GlobalUncertaintyAssignedContext from StepRepr;
+
+end GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx;

src/StepGeom/StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx.cxx

@@ -0,0 +1,260 @@
+// File:	StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx.cxx
+// Created:	Thu Dec  7 16:03:51 1995
+// Author:	Frederic MAUPAS
+//		<fma@pronox>
+
+
+#include <StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx.ixx>
+
+#include <StepGeom_GeometricRepresentationContext.hxx>
+
+#include <StepRepr_GlobalUnitAssignedContext.hxx>
+
+// --------------------------------------------------------------------------------------------------
+// Method  :
+// Purpose :
+// --------------------------------------------------------------------------------------------------
+
+StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx ()  {}
+
+// --------------------------------------------------------------------------------------------------
+// Method  :
+// Purpose :
+// --------------------------------------------------------------------------------------------------
+
+void StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::Init
+(const Handle(TCollection_HAsciiString)& aContextIdentifier,
+ const Handle(TCollection_HAsciiString)& aContextType)
+{
+  StepRepr_RepresentationContext::Init(aContextIdentifier, aContextType);
+}
+
+// --------------------------------------------------------------------------------------------------
+// Method  :
+// Purpose :
+// --------------------------------------------------------------------------------------------------
+
+void StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::Init
+(const Handle(TCollection_HAsciiString)& aContextIdentifier,
+ const Handle(TCollection_HAsciiString)& aContextType,
+ const Handle(StepGeom_GeometricRepresentationContext)& aGeometricRepresentationContext,
+ const Handle(StepRepr_GlobalUnitAssignedContext)& aGlobalUnitAssignedContext,
+ const Handle(StepRepr_GlobalUncertaintyAssignedContext)& aGlobalUncertaintyAssignedCtx)
+{
+  // --- classe own fields ---
+  geometricRepresentationContext   = aGeometricRepresentationContext;
+  globalUnitAssignedContext        = aGlobalUnitAssignedContext;
+  globalUncertaintyAssignedContext = aGlobalUncertaintyAssignedCtx;
+  // --- classe inherited fields ---
+  StepRepr_RepresentationContext::Init(aContextIdentifier, aContextType);
+}
+
+
+// --------------------------------------------------------------------------------------------------
+// Method  :
+// Purpose :
+// --------------------------------------------------------------------------------------------------
+
+void StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::Init
+(const Handle(TCollection_HAsciiString)& aContextIdentifier,
+ const Handle(TCollection_HAsciiString)& aContextType,
+ const Standard_Integer aCoordinateSpaceDimension,
+ const Handle(StepBasic_HArray1OfNamedUnit)& aUnits,
+ const Handle(StepBasic_HArray1OfUncertaintyMeasureWithUnit)& anUncertainty)
+{
+  // --- classe inherited fields ---
+
+  StepRepr_RepresentationContext::Init(aContextIdentifier, aContextType);
+  
+  // --- ANDOR componant fields : GeometricRepresentationContext ---
+  
+  geometricRepresentationContext = new StepGeom_GeometricRepresentationContext();
+  geometricRepresentationContext->Init(aContextIdentifier, aContextType, aCoordinateSpaceDimension);
+  
+  // --- ANDOR componant fields : GlobalUnitAssignedContext ---
+  
+  globalUnitAssignedContext = new StepRepr_GlobalUnitAssignedContext();
+  globalUnitAssignedContext->Init(aContextIdentifier, aContextType, aUnits);
+
+  // --- ANDOR componant fields : GlobalUncertaintyAssignedContext ---
+
+  globalUncertaintyAssignedContext = new StepRepr_GlobalUncertaintyAssignedContext();
+  globalUncertaintyAssignedContext->Init(aContextIdentifier, aContextType, anUncertainty);
+  
+}
+
+// --------------------------------------------------------------------------------------------------
+// Method  :
+// Purpose :
+// --------------------------------------------------------------------------------------------------
+
+void StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::SetGeometricRepresentationContext(const Handle(StepGeom_GeometricRepresentationContext)& aGeometricRepresentationContext)
+{
+  geometricRepresentationContext = aGeometricRepresentationContext;
+}
+
+// --------------------------------------------------------------------------------------------------
+// Method  :
+// Purpose :
+// --------------------------------------------------------------------------------------------------
+
+Handle(StepGeom_GeometricRepresentationContext) StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::GeometricRepresentationContext() const
+{
+  return geometricRepresentationContext;
+}
+
+// --------------------------------------------------------------------------------------------------
+// Method  :
+// Purpose :
+// --------------------------------------------------------------------------------------------------
+
+void StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::SetGlobalUnitAssignedContext
+(const Handle(StepRepr_GlobalUnitAssignedContext)& aGlobalUnitAssignedContext)
+{
+  globalUnitAssignedContext = aGlobalUnitAssignedContext;
+}
+
+// --------------------------------------------------------------------------------------------------
+// Method  :
+// Purpose :
+// --------------------------------------------------------------------------------------------------
+
+Handle(StepRepr_GlobalUnitAssignedContext) StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::GlobalUnitAssignedContext() const
+{
+  return globalUnitAssignedContext;
+}
+
+// --------------------------------------------------------------------------------------------------
+// Method  :
+// Purpose :
+// --------------------------------------------------------------------------------------------------
+
+void StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::SetGlobalUncertaintyAssignedContext
+(const Handle(StepRepr_GlobalUncertaintyAssignedContext)& aGlobalUncertaintyAssignedCtx)
+{
+  globalUncertaintyAssignedContext = aGlobalUncertaintyAssignedCtx;
+}
+
+
+// --------------------------------------------------------------------------------------------------
+// Method  :
+// Purpose :
+// --------------------------------------------------------------------------------------------------
+
+Handle(StepRepr_GlobalUncertaintyAssignedContext) StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::GlobalUncertaintyAssignedContext() const
+{
+  return globalUncertaintyAssignedContext;
+}
+
+//-------------------------------------------------------------------------------------
+//--- Specific Methods for AND classe field access : GeometricRepresentationContext ---
+//-------------------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------------------------------
+// Method  :
+// Purpose :
+// --------------------------------------------------------------------------------------------------
+
+void StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::SetCoordinateSpaceDimension(const Standard_Integer aCoordinateSpaceDimension)
+{
+  geometricRepresentationContext->SetCoordinateSpaceDimension(aCoordinateSpaceDimension);
+}
+
+// --------------------------------------------------------------------------------------------------
+// Method  :
+// Purpose :
+// --------------------------------------------------------------------------------------------------
+
+Standard_Integer StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::CoordinateSpaceDimension() const
+{
+  return geometricRepresentationContext->CoordinateSpaceDimension();
+}
+
+//---------------------------------------------------------------------------------
+//--- Specific Methods for AND classe field access : GlobalUnitAssignedContext  ---
+//---------------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------------------------------
+// Method  :
+// Purpose :
+// --------------------------------------------------------------------------------------------------
+
+void StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::SetUnits(const Handle(StepBasic_HArray1OfNamedUnit)& aUnits)
+{
+  globalUnitAssignedContext->SetUnits(aUnits);
+}
+
+// --------------------------------------------------------------------------------------------------
+// Method  :
+// Purpose :
+// --------------------------------------------------------------------------------------------------
+
+Handle(StepBasic_HArray1OfNamedUnit) StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::Units() const
+{
+  return globalUnitAssignedContext->Units();
+}
+
+// --------------------------------------------------------------------------------------------------
+// Method  :
+// Purpose :
+// --------------------------------------------------------------------------------------------------
+
+Handle(StepBasic_NamedUnit) StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::UnitsValue(const Standard_Integer num) const
+{
+  return globalUnitAssignedContext->UnitsValue(num);
+}
+
+// --------------------------------------------------------------------------------------------------
+// Method  :
+// Purpose :
+// --------------------------------------------------------------------------------------------------
+
+Standard_Integer StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::NbUnits () const
+{
+  return globalUnitAssignedContext->NbUnits();
+}
+
+
+//----------------------------------------------------------------------------------------
+//--- Specific Methods for AND classe field access : GlobalUncertaintyAssignedContext  ---
+//----------------------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------------------------------
+// Method  :
+// Purpose :
+// --------------------------------------------------------------------------------------------------
+
+void StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::SetUncertainty(const Handle(StepBasic_HArray1OfUncertaintyMeasureWithUnit)& aUncertainty)
+{
+  globalUncertaintyAssignedContext->SetUncertainty(aUncertainty);
+}
+
+// --------------------------------------------------------------------------------------------------
+// Method  :
+// Purpose :
+// --------------------------------------------------------------------------------------------------
+
+Handle(StepBasic_HArray1OfUncertaintyMeasureWithUnit) StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::Uncertainty() const
+{
+  return globalUncertaintyAssignedContext->Uncertainty();
+}
+
+// --------------------------------------------------------------------------------------------------
+// Method  :
+// Purpose :
+// --------------------------------------------------------------------------------------------------
+
+Handle(StepBasic_UncertaintyMeasureWithUnit) StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::UncertaintyValue(const Standard_Integer num) const 
+{
+  return globalUncertaintyAssignedContext->UncertaintyValue(num);
+}
+
+// --------------------------------------------------------------------------------------------------
+// Method  :
+// Purpose :
+// --------------------------------------------------------------------------------------------------
+
+Standard_Integer StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::NbUncertainty() const
+{
+  return globalUncertaintyAssignedContext->NbUncertainty();
+}

src/StepGeom/StepGeom_GeometricRepresentationContext.cdl

@@ -0,0 +1,39 @@
+-- File:        GeometricRepresentationContext.cdl
+-- Created:     Fri Dec  1 11:11:21 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class GeometricRepresentationContext from StepGeom
+
+inherits RepresentationContext from StepRepr
+
+uses
+
+	Integer from Standard, 
+	HAsciiString from TCollection
+is
+
+	Create returns mutable GeometricRepresentationContext;
+	---Purpose: Returns a GeometricRepresentationContext
+
+
+	Init (me : mutable;
+	      aContextIdentifier : mutable HAsciiString from TCollection;
+	      aContextType : mutable HAsciiString from TCollection) is redefined;
+
+	Init (me : mutable;
+	      aContextIdentifier : mutable HAsciiString from TCollection;
+	      aContextType : mutable HAsciiString from TCollection;
+	      aCoordinateSpaceDimension : Integer from Standard) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetCoordinateSpaceDimension(me : mutable; aCoordinateSpaceDimension : Integer);
+	CoordinateSpaceDimension (me) returns Integer;
+
+fields
+
+	coordinateSpaceDimension : Integer from Standard;
+
+end GeometricRepresentationContext;

src/StepGeom/StepGeom_GeometricRepresentationContext.cxx

@@ -0,0 +1,34 @@
+#include <StepGeom_GeometricRepresentationContext.ixx>
+
+
+StepGeom_GeometricRepresentationContext::StepGeom_GeometricRepresentationContext ()  {}
+
+void StepGeom_GeometricRepresentationContext::Init(
+	const Handle(TCollection_HAsciiString)& aContextIdentifier,
+	const Handle(TCollection_HAsciiString)& aContextType)
+{
+
+	StepRepr_RepresentationContext::Init(aContextIdentifier, aContextType);
+}
+
+void StepGeom_GeometricRepresentationContext::Init(
+	const Handle(TCollection_HAsciiString)& aContextIdentifier,
+	const Handle(TCollection_HAsciiString)& aContextType,
+	const Standard_Integer aCoordinateSpaceDimension)
+{
+	// --- classe own fields ---
+	coordinateSpaceDimension = aCoordinateSpaceDimension;
+	// --- classe inherited fields ---
+	StepRepr_RepresentationContext::Init(aContextIdentifier, aContextType);
+}
+
+
+void StepGeom_GeometricRepresentationContext::SetCoordinateSpaceDimension(const Standard_Integer aCoordinateSpaceDimension)
+{
+	coordinateSpaceDimension = aCoordinateSpaceDimension;
+}
+
+Standard_Integer StepGeom_GeometricRepresentationContext::CoordinateSpaceDimension() const
+{
+	return coordinateSpaceDimension;
+}

src/StepGeom/StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext.cdl

@@ -0,0 +1,68 @@
+-- File:        GeometricRepresentationContextAndGlobalUnitAssignedContext.cdl
+-- Created:     Thu Dec  7 14:29:18 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class GeometricRepresentationContextAndGlobalUnitAssignedContext from StepGeom 
+
+inherits RepresentationContext from StepRepr
+
+
+	--- This classe is an implementation of EXPRESS
+	--  ANDOR Subtype Declaration.
+uses
+
+	GeometricRepresentationContext from StepGeom, 
+	GlobalUnitAssignedContext from StepRepr, 
+	HAsciiString from TCollection, 
+	Integer from Standard, 
+	HArray1OfNamedUnit from StepBasic,
+	NamedUnit from StepBasic
+is
+
+	Create returns mutable GeometricRepresentationContextAndGlobalUnitAssignedContext;
+	---Purpose: Returns a GeometricRepresentationContextAndGlobalUnitAssignedContext
+
+
+	Init (me : mutable;
+	      aContextIdentifier : mutable HAsciiString from TCollection;
+	      aContextType : mutable HAsciiString from TCollection) is redefined;
+
+	Init (me : mutable;
+	      aContextIdentifier : mutable HAsciiString from TCollection;
+	      aContextType : mutable HAsciiString from TCollection;
+	      aGeometricRepresentationContext : mutable GeometricRepresentationContext from StepGeom;
+	      aGlobalUnitAssignedContext : mutable GlobalUnitAssignedContext from StepRepr) is virtual;
+
+	Init (me : mutable;
+	      aContextIdentifier : mutable HAsciiString from TCollection;
+	      aContextType : mutable HAsciiString from TCollection;
+	      aCoordinateSpaceDimension : Integer from Standard;
+	      aUnits : mutable HArray1OfNamedUnit from StepBasic) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetGeometricRepresentationContext(me : mutable; aGeometricRepresentationContext : mutable GeometricRepresentationContext);
+	GeometricRepresentationContext (me) returns mutable GeometricRepresentationContext;
+	SetGlobalUnitAssignedContext(me : mutable; aGlobalUnitAssignedContext : mutable GlobalUnitAssignedContext);
+	GlobalUnitAssignedContext (me) returns mutable GlobalUnitAssignedContext;
+
+	-- Specific Methods for ANDOR Field Data Access --
+
+	SetCoordinateSpaceDimension(me : mutable; aCoordinateSpaceDimension : Integer);
+	CoordinateSpaceDimension (me) returns Integer;
+
+	-- Specific Methods for ANDOR Field Data Access --
+
+	SetUnits(me : mutable; aUnits : mutable HArray1OfNamedUnit);
+	Units (me) returns mutable HArray1OfNamedUnit;
+	UnitsValue (me; num : Integer) returns mutable NamedUnit;
+	NbUnits (me) returns Integer;
+
+fields
+
+	geometricRepresentationContext : GeometricRepresentationContext from StepGeom;
+	globalUnitAssignedContext : GlobalUnitAssignedContext from StepRepr;
+
+end GeometricRepresentationContextAndGlobalUnitAssignedContext;

src/StepGeom/StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext.cxx

@@ -0,0 +1,108 @@
+#include <StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext.ixx>
+
+#include <StepGeom_GeometricRepresentationContext.hxx>
+
+#include <StepRepr_GlobalUnitAssignedContext.hxx>
+
+
+StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext::StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext ()  {}
+
+void StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext::Init(
+	const Handle(TCollection_HAsciiString)& aContextIdentifier,
+	const Handle(TCollection_HAsciiString)& aContextType)
+{
+
+	StepRepr_RepresentationContext::Init(aContextIdentifier, aContextType);
+}
+
+void StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext::Init(
+	const Handle(TCollection_HAsciiString)& aContextIdentifier,
+	const Handle(TCollection_HAsciiString)& aContextType,
+	const Handle(StepGeom_GeometricRepresentationContext)& aGeometricRepresentationContext,
+	const Handle(StepRepr_GlobalUnitAssignedContext)& aGlobalUnitAssignedContext)
+{
+	// --- classe own fields ---
+	geometricRepresentationContext = aGeometricRepresentationContext;
+	globalUnitAssignedContext = aGlobalUnitAssignedContext;
+	// --- classe inherited fields ---
+	StepRepr_RepresentationContext::Init(aContextIdentifier, aContextType);
+}
+
+
+void StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext::Init(
+	const Handle(TCollection_HAsciiString)& aContextIdentifier,
+	const Handle(TCollection_HAsciiString)& aContextType,
+	const Standard_Integer aCoordinateSpaceDimension,
+	const Handle(StepBasic_HArray1OfNamedUnit)& aUnits)
+{
+	// --- classe inherited fields ---
+
+	StepRepr_RepresentationContext::Init(aContextIdentifier, aContextType);
+
+	// --- ANDOR componant fields ---
+
+	geometricRepresentationContext = new StepGeom_GeometricRepresentationContext();
+	geometricRepresentationContext->Init(aContextIdentifier, aContextType, aCoordinateSpaceDimension);
+
+	// --- ANDOR componant fields ---
+
+	globalUnitAssignedContext = new StepRepr_GlobalUnitAssignedContext();
+	globalUnitAssignedContext->Init(aContextIdentifier, aContextType, aUnits);
+}
+
+
+void StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext::SetGeometricRepresentationContext(const Handle(StepGeom_GeometricRepresentationContext)& aGeometricRepresentationContext)
+{
+	geometricRepresentationContext = aGeometricRepresentationContext;
+}
+
+Handle(StepGeom_GeometricRepresentationContext) StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext::GeometricRepresentationContext() const
+{
+	return geometricRepresentationContext;
+}
+
+void StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext::SetGlobalUnitAssignedContext(const Handle(StepRepr_GlobalUnitAssignedContext)& aGlobalUnitAssignedContext)
+{
+	globalUnitAssignedContext = aGlobalUnitAssignedContext;
+}
+
+Handle(StepRepr_GlobalUnitAssignedContext) StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext::GlobalUnitAssignedContext() const
+{
+	return globalUnitAssignedContext;
+}
+
+	//--- Specific Methods for AND classe field access ---
+
+
+void StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext::SetCoordinateSpaceDimension(const Standard_Integer aCoordinateSpaceDimension)
+{
+	geometricRepresentationContext->SetCoordinateSpaceDimension(aCoordinateSpaceDimension);
+}
+
+Standard_Integer StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext::CoordinateSpaceDimension() const
+{
+	return geometricRepresentationContext->CoordinateSpaceDimension();
+}
+
+	//--- Specific Methods for AND classe field access ---
+
+
+void StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext::SetUnits(const Handle(StepBasic_HArray1OfNamedUnit)& aUnits)
+{
+	globalUnitAssignedContext->SetUnits(aUnits);
+}
+
+Handle(StepBasic_HArray1OfNamedUnit) StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext::Units() const
+{
+	return globalUnitAssignedContext->Units();
+}
+
+Handle(StepBasic_NamedUnit) StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext::UnitsValue(const Standard_Integer num) const
+{
+	return globalUnitAssignedContext->UnitsValue(num);
+}
+
+Standard_Integer StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext::NbUnits () const
+{
+	return globalUnitAssignedContext->NbUnits();
+}

src/StepGeom/StepGeom_GeometricRepresentationContextAndParametricRepresentationContext.cdl

@@ -0,0 +1,62 @@
+-- File:        GeometricRepresentationContextAndParametricRepresentationContext.cdl
+-- Created:     Thu Dec  7 14:29:18 1995
+-- Author:      FMA
+-- Copyright:   Matra-Datavision 1995
+
+
+class GeometricRepresentationContextAndParametricRepresentationContext from StepGeom 
+
+inherits RepresentationContext from StepRepr
+
+
+	--- This classe is an implementation of EXPRESS
+	--  ANDOR Subtype Declaration.
+	--  
+	--  Hand made by FMA - 1995 Feb 9th
+uses
+
+	GeometricRepresentationContext from StepGeom, 
+	ParametricRepresentationContext from StepRepr, 
+	HAsciiString from TCollection, 
+	Integer from Standard
+
+is
+
+	Create returns mutable GeometricRepresentationContextAndParametricRepresentationContext;
+	---Purpose: empty constructor
+
+
+	Init (me : mutable;
+	      aContextIdentifier : mutable HAsciiString from TCollection;
+	      aContextType : mutable HAsciiString from TCollection) is redefined;
+
+	Init (me : mutable;
+	      aContextIdentifier : mutable HAsciiString from TCollection;
+	      aContextType : mutable HAsciiString from TCollection;
+	      aGeometricRepresentationContext : mutable GeometricRepresentationContext from StepGeom;
+	      aParametricRepresentationContext : mutable ParametricRepresentationContext from StepRepr) is virtual;
+
+	Init (me : mutable;
+	      aContextIdentifier : mutable HAsciiString from TCollection;
+	      aContextType : mutable HAsciiString from TCollection;
+	      aCoordinateSpaceDimension : Integer from Standard) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetGeometricRepresentationContext(me : mutable; aGeometricRepresentationContext : mutable GeometricRepresentationContext);
+	GeometricRepresentationContext (me) returns mutable GeometricRepresentationContext;
+	SetParametricRepresentationContext(me : mutable; aParametricRepresentationContext : mutable ParametricRepresentationContext);
+	ParametricRepresentationContext (me) returns mutable ParametricRepresentationContext;
+
+	-- Specific Methods for ANDOR Field Data Access --
+
+	SetCoordinateSpaceDimension(me : mutable; aCoordinateSpaceDimension : Integer);
+	CoordinateSpaceDimension (me) returns Integer;
+
+
+fields
+
+	geometricRepresentationContext : GeometricRepresentationContext from StepGeom;
+	parametricRepresentationContext : ParametricRepresentationContext from StepRepr;
+
+end GeometricRepresentationContextAndParametricRepresentationContext;

src/StepGeom/StepGeom_GeometricRepresentationContextAndParametricRepresentationContext.cxx

@@ -0,0 +1,84 @@
+#include <StepGeom_GeometricRepresentationContextAndParametricRepresentationContext.ixx>
+
+#include <StepGeom_GeometricRepresentationContext.hxx>
+
+#include <StepRepr_GlobalUnitAssignedContext.hxx>
+
+
+StepGeom_GeometricRepresentationContextAndParametricRepresentationContext::StepGeom_GeometricRepresentationContextAndParametricRepresentationContext ()  {}
+
+void StepGeom_GeometricRepresentationContextAndParametricRepresentationContext::Init(
+	const Handle(TCollection_HAsciiString)& aContextIdentifier,
+	const Handle(TCollection_HAsciiString)& aContextType)
+{
+
+	StepRepr_RepresentationContext::Init(aContextIdentifier, aContextType);
+}
+
+void StepGeom_GeometricRepresentationContextAndParametricRepresentationContext::Init
+(const Handle(TCollection_HAsciiString)& aContextIdentifier,
+ const Handle(TCollection_HAsciiString)& aContextType,
+ const Handle(StepGeom_GeometricRepresentationContext)& aGeometricRepresentationContext,
+ const Handle(StepRepr_ParametricRepresentationContext)& aParametricRepresentationContext)
+{
+  // --- classe own fields ---
+  geometricRepresentationContext = aGeometricRepresentationContext;
+  parametricRepresentationContext= aParametricRepresentationContext;
+  // --- classe inherited fields ---
+  StepRepr_RepresentationContext::Init(aContextIdentifier, aContextType);
+}
+
+
+void StepGeom_GeometricRepresentationContextAndParametricRepresentationContext::Init
+(const Handle(TCollection_HAsciiString)& aContextIdentifier,
+ const Handle(TCollection_HAsciiString)& aContextType,
+ const Standard_Integer aCoordinateSpaceDimension)
+{
+  // --- classe inherited fields ---
+  
+  StepRepr_RepresentationContext::Init(aContextIdentifier, aContextType);
+  
+  // --- ANDOR componant fields ---
+  
+  geometricRepresentationContext = new StepGeom_GeometricRepresentationContext();
+  geometricRepresentationContext->Init(aContextIdentifier, aContextType, aCoordinateSpaceDimension);
+  
+  // --- ANDOR componant fields ---
+  
+  parametricRepresentationContext = new StepRepr_ParametricRepresentationContext();
+  parametricRepresentationContext->Init(aContextIdentifier, aContextType);
+}
+
+
+void StepGeom_GeometricRepresentationContextAndParametricRepresentationContext::SetGeometricRepresentationContext(const Handle(StepGeom_GeometricRepresentationContext)& aGeometricRepresentationContext)
+{
+  geometricRepresentationContext = aGeometricRepresentationContext;
+}
+
+Handle(StepGeom_GeometricRepresentationContext) StepGeom_GeometricRepresentationContextAndParametricRepresentationContext::GeometricRepresentationContext() const
+{
+  return geometricRepresentationContext;
+}
+
+void StepGeom_GeometricRepresentationContextAndParametricRepresentationContext::SetParametricRepresentationContext(const Handle(StepRepr_ParametricRepresentationContext)& aParametricRepresentationContext)
+{
+  parametricRepresentationContext = aParametricRepresentationContext;
+}
+
+Handle(StepRepr_ParametricRepresentationContext) StepGeom_GeometricRepresentationContextAndParametricRepresentationContext::ParametricRepresentationContext() const
+{
+	return parametricRepresentationContext;
+}
+
+//--- Specific Methods for AND classe field access ---
+
+
+void StepGeom_GeometricRepresentationContextAndParametricRepresentationContext::SetCoordinateSpaceDimension(const Standard_Integer aCoordinateSpaceDimension)
+{
+  geometricRepresentationContext->SetCoordinateSpaceDimension(aCoordinateSpaceDimension);
+}
+
+Standard_Integer StepGeom_GeometricRepresentationContextAndParametricRepresentationContext::CoordinateSpaceDimension() const
+{
+  return geometricRepresentationContext->CoordinateSpaceDimension();
+}

src/StepGeom/StepGeom_GeometricRepresentationItem.cdl

@@ -0,0 +1,20 @@
+-- File:        GeometricRepresentationItem.cdl
+-- Created:     Fri Dec  1 11:11:21 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class GeometricRepresentationItem from StepGeom 
+
+inherits RepresentationItem from StepRepr
+
+uses
+
+	HAsciiString from TCollection
+is
+
+	Create returns mutable GeometricRepresentationItem;
+	---Purpose: Returns a GeometricRepresentationItem
+
+
+end GeometricRepresentationItem;

src/StepGeom/StepGeom_GeometricRepresentationItem.cxx

@@ -0,0 +1,5 @@
+#include <StepGeom_GeometricRepresentationItem.ixx>
+
+
+StepGeom_GeometricRepresentationItem::StepGeom_GeometricRepresentationItem ()  {}
+

src/StepGeom/StepGeom_Hyperbola.cdl

@@ -0,0 +1,44 @@
+-- File:        Hyperbola.cdl
+-- Created:     Fri Dec  1 11:11:21 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class Hyperbola from StepGeom 
+
+inherits Conic from StepGeom 
+
+uses
+
+	Real from Standard, 
+	HAsciiString from TCollection, 
+	Axis2Placement from StepGeom
+is
+
+	Create returns mutable Hyperbola;
+	---Purpose: Returns a Hyperbola
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aPosition : Axis2Placement from StepGeom) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aPosition : Axis2Placement from StepGeom;
+	      aSemiAxis : Real from Standard;
+	      aSemiImagAxis : Real from Standard) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetSemiAxis(me : mutable; aSemiAxis : Real);
+	SemiAxis (me) returns Real;
+	SetSemiImagAxis(me : mutable; aSemiImagAxis : Real);
+	SemiImagAxis (me) returns Real;
+
+fields
+
+	semiAxis : Real from Standard;
+	semiImagAxis : Real from Standard;
+
+end Hyperbola;

src/StepGeom/StepGeom_Hyperbola.cxx

@@ -0,0 +1,46 @@
+#include <StepGeom_Hyperbola.ixx>
+
+
+StepGeom_Hyperbola::StepGeom_Hyperbola ()  {}
+
+void StepGeom_Hyperbola::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const StepGeom_Axis2Placement& aPosition)
+{
+
+	StepGeom_Conic::Init(aName, aPosition);
+}
+
+void StepGeom_Hyperbola::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const StepGeom_Axis2Placement& aPosition,
+	const Standard_Real aSemiAxis,
+	const Standard_Real aSemiImagAxis)
+{
+	// --- classe own fields ---
+	semiAxis = aSemiAxis;
+	semiImagAxis = aSemiImagAxis;
+	// --- classe inherited fields ---
+	StepGeom_Conic::Init(aName, aPosition);
+}
+
+
+void StepGeom_Hyperbola::SetSemiAxis(const Standard_Real aSemiAxis)
+{
+	semiAxis = aSemiAxis;
+}
+
+Standard_Real StepGeom_Hyperbola::SemiAxis() const
+{
+	return semiAxis;
+}
+
+void StepGeom_Hyperbola::SetSemiImagAxis(const Standard_Real aSemiImagAxis)
+{
+	semiImagAxis = aSemiImagAxis;
+}
+
+Standard_Real StepGeom_Hyperbola::SemiImagAxis() const
+{
+	return semiImagAxis;
+}

src/StepGeom/StepGeom_IntersectionCurve.cdl

@@ -0,0 +1,23 @@
+-- File:        IntersectionCurve.cdl
+-- Created:     Fri Dec  1 11:11:21 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class IntersectionCurve from StepGeom 
+
+inherits SurfaceCurve from StepGeom 
+
+uses
+
+	HAsciiString from TCollection, 
+	Curve from StepGeom, 
+	HArray1OfPcurveOrSurface from StepGeom, 
+	PreferredSurfaceCurveRepresentation from StepGeom
+is
+
+	Create returns mutable IntersectionCurve;
+	---Purpose: Returns a IntersectionCurve
+
+
+end IntersectionCurve;

src/StepGeom/StepGeom_IntersectionCurve.cxx

@@ -0,0 +1,5 @@
+#include <StepGeom_IntersectionCurve.ixx>
+
+
+StepGeom_IntersectionCurve::StepGeom_IntersectionCurve ()  {}
+

src/StepGeom/StepGeom_Line.cdl

@@ -0,0 +1,42 @@
+-- File:        Line.cdl
+-- Created:     Fri Dec  1 11:11:22 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class Line from StepGeom 
+
+inherits Curve from StepGeom 
+
+uses
+
+	CartesianPoint from StepGeom, 
+	Vector from StepGeom, 
+	HAsciiString from TCollection
+is
+
+	Create returns mutable Line;
+	---Purpose: Returns a Line
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aPnt : mutable CartesianPoint from StepGeom;
+	      aDir : mutable Vector from StepGeom) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetPnt(me : mutable; aPnt : mutable CartesianPoint);
+	Pnt (me) returns mutable CartesianPoint;
+	SetDir(me : mutable; aDir : mutable Vector);
+	Dir (me) returns mutable Vector;
+
+fields
+
+	pnt : CartesianPoint from StepGeom;
+	dir : Vector from StepGeom;
+
+end Line;

src/StepGeom/StepGeom_Line.cxx

@@ -0,0 +1,44 @@
+#include <StepGeom_Line.ixx>
+
+
+StepGeom_Line::StepGeom_Line ()  {}
+
+void StepGeom_Line::Init(
+	const Handle(TCollection_HAsciiString)& aName)
+{
+
+	StepRepr_RepresentationItem::Init(aName);
+}
+
+void StepGeom_Line::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Handle(StepGeom_CartesianPoint)& aPnt,
+	const Handle(StepGeom_Vector)& aDir)
+{
+	// --- classe own fields ---
+	pnt = aPnt;
+	dir = aDir;
+	// --- classe inherited fields ---
+	StepRepr_RepresentationItem::Init(aName);
+}
+
+
+void StepGeom_Line::SetPnt(const Handle(StepGeom_CartesianPoint)& aPnt)
+{
+	pnt = aPnt;
+}
+
+Handle(StepGeom_CartesianPoint) StepGeom_Line::Pnt() const
+{
+	return pnt;
+}
+
+void StepGeom_Line::SetDir(const Handle(StepGeom_Vector)& aDir)
+{
+	dir = aDir;
+}
+
+Handle(StepGeom_Vector) StepGeom_Line::Dir() const
+{
+	return dir;
+}

src/StepGeom/StepGeom_OffsetCurve3d.cdl

@@ -0,0 +1,51 @@
+-- File:        OffsetCurve3d.cdl
+-- Created:     Fri Dec  1 11:11:22 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class OffsetCurve3d from StepGeom 
+
+inherits Curve from StepGeom 
+
+uses
+
+	Real from Standard, 
+	Logical from StepData, 
+	Direction from StepGeom, 
+	HAsciiString from TCollection
+is
+
+	Create returns mutable OffsetCurve3d;
+	---Purpose: Returns a OffsetCurve3d
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aBasisCurve : mutable Curve from StepGeom;
+	      aDistance : Real from Standard;
+	      aSelfIntersect : Logical from StepData;
+	      aRefDirection : mutable Direction from StepGeom) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetBasisCurve(me : mutable; aBasisCurve : mutable Curve);
+	BasisCurve (me) returns mutable Curve;
+	SetDistance(me : mutable; aDistance : Real);
+	Distance (me) returns Real;
+	SetSelfIntersect(me : mutable; aSelfIntersect : Logical);
+	SelfIntersect (me) returns Logical;
+	SetRefDirection(me : mutable; aRefDirection : mutable Direction);
+	RefDirection (me) returns mutable Direction;
+
+fields
+
+	basisCurve : Curve from StepGeom;
+	distance : Real from Standard;
+	selfIntersect : Logical from StepData;
+	refDirection : Direction from StepGeom;
+
+end OffsetCurve3d;

src/StepGeom/StepGeom_OffsetCurve3d.cxx

@@ -0,0 +1,68 @@
+#include <StepGeom_OffsetCurve3d.ixx>
+
+
+StepGeom_OffsetCurve3d::StepGeom_OffsetCurve3d ()  {}
+
+void StepGeom_OffsetCurve3d::Init(
+	const Handle(TCollection_HAsciiString)& aName)
+{
+
+	StepRepr_RepresentationItem::Init(aName);
+}
+
+void StepGeom_OffsetCurve3d::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Handle(StepGeom_Curve)& aBasisCurve,
+	const Standard_Real aDistance,
+	const StepData_Logical aSelfIntersect,
+	const Handle(StepGeom_Direction)& aRefDirection)
+{
+	// --- classe own fields ---
+	basisCurve = aBasisCurve;
+	distance = aDistance;
+	selfIntersect = aSelfIntersect;
+	refDirection = aRefDirection;
+	// --- classe inherited fields ---
+	StepRepr_RepresentationItem::Init(aName);
+}
+
+
+void StepGeom_OffsetCurve3d::SetBasisCurve(const Handle(StepGeom_Curve)& aBasisCurve)
+{
+	basisCurve = aBasisCurve;
+}
+
+Handle(StepGeom_Curve) StepGeom_OffsetCurve3d::BasisCurve() const
+{
+	return basisCurve;
+}
+
+void StepGeom_OffsetCurve3d::SetDistance(const Standard_Real aDistance)
+{
+	distance = aDistance;
+}
+
+Standard_Real StepGeom_OffsetCurve3d::Distance() const
+{
+	return distance;
+}
+
+void StepGeom_OffsetCurve3d::SetSelfIntersect(const StepData_Logical aSelfIntersect)
+{
+	selfIntersect = aSelfIntersect;
+}
+
+StepData_Logical StepGeom_OffsetCurve3d::SelfIntersect() const
+{
+	return selfIntersect;
+}
+
+void StepGeom_OffsetCurve3d::SetRefDirection(const Handle(StepGeom_Direction)& aRefDirection)
+{
+	refDirection = aRefDirection;
+}
+
+Handle(StepGeom_Direction) StepGeom_OffsetCurve3d::RefDirection() const
+{
+	return refDirection;
+}

src/StepGeom/StepGeom_OffsetSurface.cdl

@@ -0,0 +1,46 @@
+-- File:        OffsetSurface.cdl
+-- Created:     Fri Dec  1 11:11:22 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class OffsetSurface from StepGeom 
+
+inherits Surface from StepGeom 
+
+uses
+
+	Real from Standard, 
+	Logical from StepData, 
+	HAsciiString from TCollection
+is
+
+	Create returns mutable OffsetSurface;
+	---Purpose: Returns a OffsetSurface
+
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection) is redefined;
+
+	Init (me : mutable;
+	      aName : mutable HAsciiString from TCollection;
+	      aBasisSurface : mutable Surface from StepGeom;
+	      aDistance : Real from Standard;
+	      aSelfIntersect : Logical from StepData) is virtual;
+
+	-- Specific Methods for Field Data Access --
+
+	SetBasisSurface(me : mutable; aBasisSurface : mutable Surface);
+	BasisSurface (me) returns mutable Surface;
+	SetDistance(me : mutable; aDistance : Real);
+	Distance (me) returns Real;
+	SetSelfIntersect(me : mutable; aSelfIntersect : Logical);
+	SelfIntersect (me) returns Logical;
+
+fields
+
+	basisSurface : Surface from StepGeom;
+	distance : Real from Standard;
+	selfIntersect : Logical from StepData;
+
+end OffsetSurface;

src/StepGeom/StepGeom_OffsetSurface.cxx

@@ -0,0 +1,56 @@
+#include <StepGeom_OffsetSurface.ixx>
+
+
+StepGeom_OffsetSurface::StepGeom_OffsetSurface ()  {}
+
+void StepGeom_OffsetSurface::Init(
+	const Handle(TCollection_HAsciiString)& aName)
+{
+
+	StepRepr_RepresentationItem::Init(aName);
+}
+
+void StepGeom_OffsetSurface::Init(
+	const Handle(TCollection_HAsciiString)& aName,
+	const Handle(StepGeom_Surface)& aBasisSurface,
+	const Standard_Real aDistance,
+	const StepData_Logical aSelfIntersect)
+{
+	// --- classe own fields ---
+	basisSurface = aBasisSurface;
+	distance = aDistance;
+	selfIntersect = aSelfIntersect;
+	// --- classe inherited fields ---
+	StepRepr_RepresentationItem::Init(aName);
+}
+
+
+void StepGeom_OffsetSurface::SetBasisSurface(const Handle(StepGeom_Surface)& aBasisSurface)
+{
+	basisSurface = aBasisSurface;
+}
+
+Handle(StepGeom_Surface) StepGeom_OffsetSurface::BasisSurface() const
+{
+	return basisSurface;
+}
+
+void StepGeom_OffsetSurface::SetDistance(const Standard_Real aDistance)
+{
+	distance = aDistance;
+}
+
+Standard_Real StepGeom_OffsetSurface::Distance() const
+{
+	return distance;
+}
+
+void StepGeom_OffsetSurface::SetSelfIntersect(const StepData_Logical aSelfIntersect)
+{
+	selfIntersect = aSelfIntersect;
+}
+
+StepData_Logical StepGeom_OffsetSurface::SelfIntersect() const
+{
+	return selfIntersect;
+}

src/StepGeom/StepGeom_OrientedSurface.cdl

@@ -0,0 +1,31 @@
+-- File:	StepGeom_OrientedSurface.cdl
+-- Created:	Fri Jan  4 17:42:44 2002 
+-- Author:	data exchange team
+-- Generator:	ExpToCas (EXPRESS -> CASCADE/XSTEP Translator) V1.1
+-- Copyright:	Matra Datavision 2000
+
+class OrientedSurface from StepGeom
+inherits Surface from StepGeom
+
+    ---Purpose: Representation of STEP entity OrientedSurface
+
+uses
+    HAsciiString from TCollection
+
+is
+    Create returns OrientedSurface from StepGeom;
+	---Purpose: Empty constructor
+
+    Init (me: mutable; aRepresentationItem_Name: HAsciiString from TCollection;
+                       aOrientation: Boolean);
+	---Purpose: Initialize all fields (own and inherited)
+
+    Orientation (me) returns Boolean;
+	---Purpose: Returns field Orientation
+    SetOrientation (me: mutable; Orientation: Boolean);
+	---Purpose: Set field Orientation
+
+fields
+    theOrientation: Boolean;
+
+end OrientedSurface;

src/StepGeom/StepGeom_OrientedSurface.cxx

@@ -0,0 +1,49 @@
+// File:	StepGeom_OrientedSurface.cxx
+// Created:	Fri Jan  4 17:42:44 2002 
+// Author:	data exchange team
+// Generator:	ExpToCas (EXPRESS -> CASCADE/XSTEP Translator) V1.1
+// Copyright:	Matra Datavision 2000
+
+#include <StepGeom_OrientedSurface.ixx>
+
+//=======================================================================
+//function : StepGeom_OrientedSurface
+//purpose  : 
+//=======================================================================
+
+StepGeom_OrientedSurface::StepGeom_OrientedSurface ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose  : 
+//=======================================================================
+
+void StepGeom_OrientedSurface::Init (const Handle(TCollection_HAsciiString) &aRepresentationItem_Name,
+                                     const Standard_Boolean aOrientation)
+{
+  StepGeom_Surface::Init(aRepresentationItem_Name);
+
+  theOrientation = aOrientation;
+}
+
+//=======================================================================
+//function : Orientation
+//purpose  : 
+//=======================================================================
+
+Standard_Boolean StepGeom_OrientedSurface::Orientation () const
+{
+  return theOrientation;
+}
+
+//=======================================================================
+//function : SetOrientation
+//purpose  : 
+//=======================================================================
+
+void StepGeom_OrientedSurface::SetOrientation (const Standard_Boolean aOrientation)
+{
+  theOrientation = aOrientation;
+}

src/StepGeom/StepGeom_OuterBoundaryCurve.cdl

@@ -0,0 +1,22 @@
+-- File:        OuterBoundaryCurve.cdl
+-- Created:     Fri Dec  1 11:11:23 1995
+-- Author:      EXPRESS->CDL V0.2 Translator
+-- Copyright:   Matra-Datavision 1993
+
+
+class OuterBoundaryCurve from StepGeom 
+
+inherits BoundaryCurve from StepGeom 
+
+uses
+
+	HAsciiString from TCollection, 
+	HArray1OfCompositeCurveSegment from StepGeom, 
+	Logical from StepData
+is
+
+	Create returns mutable OuterBoundaryCurve;
+	---Purpose: Returns a OuterBoundaryCurve
+
+
+end OuterBoundaryCurve;