- add new STEP entities.
n RWStepElement
n RWStepFEA
n RWStepGeom
+n RWStepKinematics
n RWStepRepr
n RWStepShape
n RWStepVisual
n StepElement
n StepFEA
n StepGeom
+n StepKinematics
n StepRepr
n StepSelect
n StepShape
#include <RWStepGeom_RWUniformSurface.hxx>
#include <RWStepGeom_RWUniformSurfaceAndRationalBSplineSurface.hxx>
#include <RWStepGeom_RWVector.hxx>
+#include <RWStepGeom_RWSuParameters.hxx>
#include <RWStepRepr_RWAssemblyComponentUsage.hxx>
#include <RWStepRepr_RWAssemblyComponentUsageSubstitute.hxx>
#include <RWStepRepr_RWCompositeShapeAspect.hxx>
#include <RWStepRepr_RWRepresentation.hxx>
#include <RWStepRepr_RWRepresentationContext.hxx>
#include <RWStepRepr_RWRepresentationItem.hxx>
+#include <RWStepRepr_RWRepresentationContextReference.hxx>
+#include <RWStepRepr_RWRepresentationReference.hxx>
#include <RWStepRepr_RWRepresentationMap.hxx>
#include <RWStepRepr_RWRepresentationRelationship.hxx>
#include <RWStepRepr_RWRepresentationRelationshipWithTransformation.hxx>
#include <StepGeom_ReparametrisedCompositeCurveSegment.hxx>
#include <StepGeom_SeamCurve.hxx>
#include <StepGeom_SphericalSurface.hxx>
+#include <StepGeom_SuParameters.hxx>
#include <StepGeom_Surface.hxx>
#include <StepGeom_SurfaceCurve.hxx>
#include <StepGeom_SurfaceCurveAndBoundedCurve.hxx>
#include <StepRepr_QuantifiedAssemblyComponentUsage.hxx>
#include <StepRepr_Representation.hxx>
#include <StepRepr_RepresentationContext.hxx>
+#include <StepRepr_RepresentationContextReference.hxx>
#include <StepRepr_RepresentationItem.hxx>
#include <StepRepr_RepresentationMap.hxx>
+#include <StepRepr_RepresentationReference.hxx>
#include <StepRepr_RepresentationRelationship.hxx>
#include <StepRepr_RepresentationRelationshipWithTransformation.hxx>
#include <StepRepr_ReprItemAndLengthMeasureWithUnit.hxx>
#include <StepVisual_AnnotationCurveOccurrenceAndGeomReprItem.hxx>
#include <RWStepVisual_RWAnnotationCurveOccurrenceAndGeomReprItem.hxx>
+// Added for kinematics implementation
+#include <RWStepKinematics_RWActuatedKinPairAndOrderKinPair.hxx>
+#include <RWStepKinematics_RWActuatedKinematicPair.hxx>
+#include <RWStepKinematics_RWContextDependentKinematicLinkRepresentation.hxx>
+#include <RWStepKinematics_RWCylindricalPair.hxx>
+#include <RWStepKinematics_RWCylindricalPairValue.hxx>
+#include <RWStepKinematics_RWCylindricalPairWithRange.hxx>
+#include <RWStepKinematics_RWFullyConstrainedPair.hxx>
+#include <RWStepKinematics_RWGearPair.hxx>
+#include <RWStepKinematics_RWGearPairValue.hxx>
+#include <RWStepKinematics_RWGearPairWithRange.hxx>
+#include <RWStepKinematics_RWHomokineticPair.hxx>
+#include <RWStepKinematics_RWKinematicJoint.hxx>
+#include <RWStepKinematics_RWKinematicLink.hxx>
+#include <RWStepKinematics_RWKinematicLinkRepresentationAssociation.hxx>
+#include <RWStepKinematics_RWKinematicPropertyMechanismRepresentation.hxx>
+#include <RWStepKinematics_RWKinematicTopologyDirectedStructure.hxx>
+#include <RWStepKinematics_RWKinematicTopologyNetworkStructure.hxx>
+#include <RWStepKinematics_RWKinematicTopologyStructure.hxx>
+#include <RWStepKinematics_RWLinearFlexibleAndPinionPair.hxx>
+#include <RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair.hxx>
+#include <RWStepKinematics_RWLinearFlexibleLinkRepresentation.hxx>
+#include <RWStepKinematics_RWLowOrderKinematicPair.hxx>
+#include <RWStepKinematics_RWLowOrderKinematicPairValue.hxx>
+#include <RWStepKinematics_RWLowOrderKinematicPairWithRange.hxx>
+#include <RWStepKinematics_RWMechanismRepresentation.hxx>
+#include <RWStepKinematics_RWMechanismStateRepresentation.hxx>
+#include <RWStepKinematics_RWOrientedJoint.hxx>
+#include <RWStepKinematics_RWPairRepresentationRelationship.hxx>
+#include <RWStepKinematics_RWPlanarCurvePair.hxx>
+#include <RWStepKinematics_RWPlanarCurvePairRange.hxx>
+#include <RWStepKinematics_RWPlanarPair.hxx>
+#include <RWStepKinematics_RWPlanarPairValue.hxx>
+#include <RWStepKinematics_RWPlanarPairWithRange.hxx>
+#include <RWStepKinematics_RWPointOnPlanarCurvePair.hxx>
+#include <RWStepKinematics_RWPointOnPlanarCurvePairValue.hxx>
+#include <RWStepKinematics_RWPointOnPlanarCurvePairWithRange.hxx>
+#include <RWStepKinematics_RWPointOnSurfacePair.hxx>
+#include <RWStepKinematics_RWPointOnSurfacePairValue.hxx>
+#include <RWStepKinematics_RWPointOnSurfacePairWithRange.hxx>
+#include <RWStepKinematics_RWPrismaticPair.hxx>
+#include <RWStepKinematics_RWPrismaticPairValue.hxx>
+#include <RWStepKinematics_RWPrismaticPairWithRange.hxx>
+#include <RWStepKinematics_RWProductDefinitionKinematics.hxx>
+#include <RWStepKinematics_RWProductDefinitionRelationshipKinematics.hxx>
+#include <RWStepKinematics_RWRackAndPinionPair.hxx>
+#include <RWStepKinematics_RWRackAndPinionPairValue.hxx>
+#include <RWStepKinematics_RWRackAndPinionPairWithRange.hxx>
+#include <RWStepKinematics_RWRevolutePair.hxx>
+#include <RWStepKinematics_RWRevolutePairValue.hxx>
+#include <RWStepKinematics_RWRevolutePairWithRange.hxx>
+#include <RWStepKinematics_RWRigidLinkRepresentation.hxx>
+#include <RWStepKinematics_RWRollingCurvePair.hxx>
+#include <RWStepKinematics_RWRollingCurvePairValue.hxx>
+#include <RWStepKinematics_RWRollingSurfacePair.hxx>
+#include <RWStepKinematics_RWRollingSurfacePairValue.hxx>
+#include <RWStepKinematics_RWRotationAboutDirection.hxx>
+#include <RWStepKinematics_RWScrewPair.hxx>
+#include <RWStepKinematics_RWScrewPairValue.hxx>
+#include <RWStepKinematics_RWScrewPairWithRange.hxx>
+#include <RWStepKinematics_RWSlidingCurvePair.hxx>
+#include <RWStepKinematics_RWSlidingCurvePairValue.hxx>
+#include <RWStepKinematics_RWSlidingSurfacePair.hxx>
+#include <RWStepKinematics_RWSlidingSurfacePairValue.hxx>
+#include <RWStepKinematics_RWSphericalPair.hxx>
+#include <RWStepKinematics_RWSphericalPairValue.hxx>
+#include <RWStepKinematics_RWSphericalPairWithPin.hxx>
+#include <RWStepKinematics_RWSphericalPairWithPinAndRange.hxx>
+#include <RWStepKinematics_RWSphericalPairWithRange.hxx>
+#include <RWStepKinematics_RWSurfacePairWithRange.hxx>
+#include <RWStepKinematics_RWUnconstrainedPair.hxx>
+#include <RWStepKinematics_RWUnconstrainedPairValue.hxx>
+#include <RWStepKinematics_RWUniversalPair.hxx>
+#include <RWStepKinematics_RWUniversalPairValue.hxx>
+#include <RWStepKinematics_RWUniversalPairWithRange.hxx>
+
+#include <StepKinematics_ActuatedKinematicPair.hxx>
+#include <StepKinematics_ActuatedKinPairAndOrderKinPair.hxx>
+#include <StepKinematics_ContextDependentKinematicLinkRepresentation.hxx>
+#include <StepKinematics_CylindricalPair.hxx>
+#include <StepKinematics_CylindricalPairValue.hxx>
+#include <StepKinematics_CylindricalPairWithRange.hxx>
+#include <StepKinematics_FullyConstrainedPair.hxx>
+#include <StepKinematics_GearPair.hxx>
+#include <StepKinematics_GearPairValue.hxx>
+#include <StepKinematics_GearPairWithRange.hxx>
+#include <StepKinematics_HomokineticPair.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepKinematics_KinematicLink.hxx>
+#include <StepKinematics_KinematicLinkRepresentationAssociation.hxx>
+#include <StepKinematics_KinematicPropertyMechanismRepresentation.hxx>
+#include <StepKinematics_KinematicTopologyDirectedStructure.hxx>
+#include <StepKinematics_KinematicTopologyNetworkStructure.hxx>
+#include <StepKinematics_KinematicTopologyStructure.hxx>
+#include <StepKinematics_LinearFlexibleAndPinionPair.hxx>
+#include <StepKinematics_LinearFlexibleAndPlanarCurvePair.hxx>
+#include <StepKinematics_LinearFlexibleLinkRepresentation.hxx>
+#include <StepKinematics_LowOrderKinematicPair.hxx>
+#include <StepKinematics_LowOrderKinematicPairValue.hxx>
+#include <StepKinematics_LowOrderKinematicPairWithRange.hxx>
+#include <StepKinematics_MechanismRepresentation.hxx>
+#include <StepKinematics_MechanismStateRepresentation.hxx>
+#include <StepKinematics_OrientedJoint.hxx>
+#include <StepKinematics_PairRepresentationRelationship.hxx>
+#include <StepKinematics_PlanarCurvePair.hxx>
+#include <StepKinematics_PlanarCurvePairRange.hxx>
+#include <StepKinematics_PlanarPair.hxx>
+#include <StepKinematics_PlanarPairValue.hxx>
+#include <StepKinematics_PlanarPairWithRange.hxx>
+#include <StepKinematics_PointOnPlanarCurvePair.hxx>
+#include <StepKinematics_PointOnPlanarCurvePairValue.hxx>
+#include <StepKinematics_PointOnPlanarCurvePairWithRange.hxx>
+#include <StepKinematics_PointOnSurfacePair.hxx>
+#include <StepKinematics_PointOnSurfacePairValue.hxx>
+#include <StepKinematics_PointOnSurfacePairWithRange.hxx>
+#include <StepKinematics_PrismaticPair.hxx>
+#include <StepKinematics_PrismaticPairValue.hxx>
+#include <StepKinematics_PrismaticPairWithRange.hxx>
+#include <StepKinematics_ProductDefinitionKinematics.hxx>
+#include <StepKinematics_ProductDefinitionRelationshipKinematics.hxx>
+#include <StepKinematics_RackAndPinionPair.hxx>
+#include <StepKinematics_RackAndPinionPairValue.hxx>
+#include <StepKinematics_RackAndPinionPairWithRange.hxx>
+#include <StepKinematics_RevolutePair.hxx>
+#include <StepKinematics_RevolutePairValue.hxx>
+#include <StepKinematics_RevolutePairWithRange.hxx>
+#include <StepKinematics_RigidLinkRepresentation.hxx>
+#include <StepKinematics_RollingCurvePair.hxx>
+#include <StepKinematics_RollingCurvePairValue.hxx>
+#include <StepKinematics_RollingSurfacePair.hxx>
+#include <StepKinematics_RollingSurfacePairValue.hxx>
+#include <StepKinematics_RotationAboutDirection.hxx>
+#include <StepKinematics_ScrewPair.hxx>
+#include <StepKinematics_ScrewPairValue.hxx>
+#include <StepKinematics_ScrewPairWithRange.hxx>
+#include <StepKinematics_SlidingCurvePair.hxx>
+#include <StepKinematics_SlidingCurvePairValue.hxx>
+#include <StepKinematics_SlidingSurfacePair.hxx>
+#include <StepKinematics_SlidingSurfacePairValue.hxx>
+#include <StepKinematics_SphericalPair.hxx>
+#include <StepKinematics_SphericalPairValue.hxx>
+#include <StepKinematics_SphericalPairWithPin.hxx>
+#include <StepKinematics_SphericalPairWithPinAndRange.hxx>
+#include <StepKinematics_SphericalPairWithRange.hxx>
+#include <StepKinematics_SurfacePairWithRange.hxx>
+#include <StepKinematics_UnconstrainedPair.hxx>
+#include <StepKinematics_UnconstrainedPairValue.hxx>
+#include <StepKinematics_UniversalPair.hxx>
+#include <StepKinematics_UniversalPairValue.hxx>
+#include <StepKinematics_UniversalPairWithRange.hxx>
+
+
static Standard_Integer catsh,catdr,catstr,catdsc,cataux;
tool.Share(anent, iter);
}
break;
+ case 724:
+ {
+ DeclareAndCast(StepRepr_RepresentationContextReference, anent, ent);
+ RWStepRepr_RWRepresentationContextReference tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 725:
+ {
+ DeclareAndCast(StepRepr_RepresentationReference, anent, ent);
+ RWStepRepr_RWRepresentationReference tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 726:
+ {
+ DeclareAndCast(StepGeom_SuParameters, anent, ent);
+ RWStepGeom_RWSuParameters tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 727:
+ {
+ DeclareAndCast(StepKinematics_RotationAboutDirection, anent, ent);
+ RWStepKinematics_RWRotationAboutDirection tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 728:
+ {
+ DeclareAndCast(StepKinematics_KinematicJoint, anent, ent);
+ RWStepKinematics_RWKinematicJoint tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 729:
+ {
+ DeclareAndCast(StepKinematics_ActuatedKinematicPair, anent, ent);
+ RWStepKinematics_RWActuatedKinematicPair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 730:
+ {
+ DeclareAndCast(StepKinematics_ContextDependentKinematicLinkRepresentation, anent, ent);
+ RWStepKinematics_RWContextDependentKinematicLinkRepresentation tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 731:
+ {
+ DeclareAndCast(StepKinematics_CylindricalPair, anent, ent);
+ RWStepKinematics_RWCylindricalPair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 732:
+ {
+ DeclareAndCast(StepKinematics_CylindricalPairValue, anent, ent);
+ RWStepKinematics_RWCylindricalPairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 733:
+ {
+ DeclareAndCast(StepKinematics_CylindricalPairWithRange, anent, ent);
+ RWStepKinematics_RWCylindricalPairWithRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 734:
+ {
+ DeclareAndCast(StepKinematics_FullyConstrainedPair, anent, ent);
+ RWStepKinematics_RWFullyConstrainedPair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 735:
+ {
+ DeclareAndCast(StepKinematics_GearPair, anent, ent);
+ RWStepKinematics_RWGearPair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 736:
+ {
+ DeclareAndCast(StepKinematics_GearPairValue, anent, ent);
+ RWStepKinematics_RWGearPairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 737:
+ {
+ DeclareAndCast(StepKinematics_GearPairWithRange, anent, ent);
+ RWStepKinematics_RWGearPairWithRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 738:
+ {
+ DeclareAndCast(StepKinematics_HomokineticPair, anent, ent);
+ RWStepKinematics_RWHomokineticPair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 739:
+ {
+ DeclareAndCast(StepKinematics_KinematicLink, anent, ent);
+ RWStepKinematics_RWKinematicLink tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 740:
+ {
+ DeclareAndCast(StepKinematics_KinematicLinkRepresentationAssociation, anent, ent);
+ RWStepKinematics_RWKinematicLinkRepresentationAssociation tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 741:
+ {
+ DeclareAndCast(StepKinematics_KinematicPropertyMechanismRepresentation, anent, ent);
+ RWStepKinematics_RWKinematicPropertyMechanismRepresentation tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 742:
+ {
+ DeclareAndCast(StepKinematics_KinematicTopologyStructure, anent, ent);
+ RWStepKinematics_RWKinematicTopologyStructure tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 743:
+ {
+ DeclareAndCast(StepKinematics_LowOrderKinematicPair, anent, ent);
+ RWStepKinematics_RWLowOrderKinematicPair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 744:
+ {
+ DeclareAndCast(StepKinematics_LowOrderKinematicPairValue, anent, ent);
+ RWStepKinematics_RWLowOrderKinematicPairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 745:
+ {
+ DeclareAndCast(StepKinematics_LowOrderKinematicPairWithRange, anent, ent);
+ RWStepKinematics_RWLowOrderKinematicPairWithRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 746:
+ {
+ DeclareAndCast(StepKinematics_MechanismRepresentation, anent, ent);
+ RWStepKinematics_RWMechanismRepresentation tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 747:
+ {
+ DeclareAndCast(StepKinematics_OrientedJoint, anent, ent);
+ RWStepKinematics_RWOrientedJoint tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 748:
+ {
+ DeclareAndCast(StepKinematics_PlanarCurvePair, anent, ent);
+ RWStepKinematics_RWPlanarCurvePair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 749:
+ {
+ DeclareAndCast(StepKinematics_PlanarCurvePairRange, anent, ent);
+ RWStepKinematics_RWPlanarCurvePairRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 750:
+ {
+ DeclareAndCast(StepKinematics_PlanarPair, anent, ent);
+ RWStepKinematics_RWPlanarPair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 751:
+ {
+ DeclareAndCast(StepKinematics_PlanarPairValue, anent, ent);
+ RWStepKinematics_RWPlanarPairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 752:
+ {
+ DeclareAndCast(StepKinematics_PlanarPairWithRange, anent, ent);
+ RWStepKinematics_RWPlanarPairWithRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 753:
+ {
+ DeclareAndCast(StepKinematics_PointOnPlanarCurvePair, anent, ent);
+ RWStepKinematics_RWPointOnPlanarCurvePair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 754:
+ {
+ DeclareAndCast(StepKinematics_PointOnPlanarCurvePairValue, anent, ent);
+ RWStepKinematics_RWPointOnPlanarCurvePairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 755:
+ {
+ DeclareAndCast(StepKinematics_PointOnPlanarCurvePairWithRange, anent, ent);
+ RWStepKinematics_RWPointOnPlanarCurvePairWithRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 756:
+ {
+ DeclareAndCast(StepKinematics_PointOnSurfacePair, anent, ent);
+ RWStepKinematics_RWPointOnSurfacePair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 757:
+ {
+ DeclareAndCast(StepKinematics_PointOnSurfacePairValue, anent, ent);
+ RWStepKinematics_RWPointOnSurfacePairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 758:
+ {
+ DeclareAndCast(StepKinematics_PointOnSurfacePairWithRange, anent, ent);
+ RWStepKinematics_RWPointOnSurfacePairWithRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 759:
+ {
+ DeclareAndCast(StepKinematics_PrismaticPair, anent, ent);
+ RWStepKinematics_RWPrismaticPair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 760:
+ {
+ DeclareAndCast(StepKinematics_PrismaticPairValue, anent, ent);
+ RWStepKinematics_RWPrismaticPairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 761:
+ {
+ DeclareAndCast(StepKinematics_PrismaticPairWithRange, anent, ent);
+ RWStepKinematics_RWPrismaticPairWithRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 762:
+ {
+ DeclareAndCast(StepKinematics_ProductDefinitionKinematics, anent, ent);
+ RWStepKinematics_RWProductDefinitionKinematics tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 763:
+ {
+ DeclareAndCast(StepKinematics_ProductDefinitionRelationshipKinematics, anent, ent);
+ RWStepKinematics_RWProductDefinitionRelationshipKinematics tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 764:
+ {
+ DeclareAndCast(StepKinematics_RackAndPinionPair, anent, ent);
+ RWStepKinematics_RWRackAndPinionPair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 765:
+ {
+ DeclareAndCast(StepKinematics_RackAndPinionPairValue, anent, ent);
+ RWStepKinematics_RWRackAndPinionPairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 766:
+ {
+ DeclareAndCast(StepKinematics_RackAndPinionPairWithRange, anent, ent);
+ RWStepKinematics_RWRackAndPinionPairWithRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 767:
+ {
+ DeclareAndCast(StepKinematics_RevolutePair, anent, ent);
+ RWStepKinematics_RWRevolutePair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 768:
+ {
+ DeclareAndCast(StepKinematics_RevolutePairValue, anent, ent);
+ RWStepKinematics_RWRevolutePairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 769:
+ {
+ DeclareAndCast(StepKinematics_RevolutePairWithRange, anent, ent);
+ RWStepKinematics_RWRevolutePairWithRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 770:
+ {
+ DeclareAndCast(StepKinematics_RollingCurvePair, anent, ent);
+ RWStepKinematics_RWRollingCurvePair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 771:
+ {
+ DeclareAndCast(StepKinematics_RollingCurvePairValue, anent, ent);
+ RWStepKinematics_RWRollingCurvePairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 772:
+ {
+ DeclareAndCast(StepKinematics_RollingSurfacePair, anent, ent);
+ RWStepKinematics_RWRollingSurfacePair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 773:
+ {
+ DeclareAndCast(StepKinematics_RollingSurfacePairValue, anent, ent);
+ RWStepKinematics_RWRollingSurfacePairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 774:
+ {
+ DeclareAndCast(StepKinematics_ScrewPair, anent, ent);
+ RWStepKinematics_RWScrewPair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 775:
+ {
+ DeclareAndCast(StepKinematics_ScrewPairValue, anent, ent);
+ RWStepKinematics_RWScrewPairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 776:
+ {
+ DeclareAndCast(StepKinematics_ScrewPairWithRange, anent, ent);
+ RWStepKinematics_RWScrewPairWithRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 777:
+ {
+ DeclareAndCast(StepKinematics_SlidingCurvePair, anent, ent);
+ RWStepKinematics_RWSlidingCurvePair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 778:
+ {
+ DeclareAndCast(StepKinematics_SlidingCurvePairValue, anent, ent);
+ RWStepKinematics_RWSlidingCurvePairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 779:
+ {
+ DeclareAndCast(StepKinematics_SlidingSurfacePair, anent, ent);
+ RWStepKinematics_RWSlidingSurfacePair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 780:
+ {
+ DeclareAndCast(StepKinematics_SlidingSurfacePairValue, anent, ent);
+ RWStepKinematics_RWSlidingSurfacePairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 781:
+ {
+ DeclareAndCast(StepKinematics_SphericalPair, anent, ent);
+ RWStepKinematics_RWSphericalPair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 782:
+ {
+ DeclareAndCast(StepKinematics_SphericalPairValue, anent, ent);
+ RWStepKinematics_RWSphericalPairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 783:
+ {
+ DeclareAndCast(StepKinematics_SphericalPairWithPin, anent, ent);
+ RWStepKinematics_RWSphericalPairWithPin tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 784:
+ {
+ DeclareAndCast(StepKinematics_SphericalPairWithPinAndRange, anent, ent);
+ RWStepKinematics_RWSphericalPairWithPinAndRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 785:
+ {
+ DeclareAndCast(StepKinematics_SphericalPairWithRange, anent, ent);
+ RWStepKinematics_RWSphericalPairWithRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 786:
+ {
+ DeclareAndCast(StepKinematics_SurfacePairWithRange, anent, ent);
+ RWStepKinematics_RWSurfacePairWithRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 787:
+ {
+ DeclareAndCast(StepKinematics_UnconstrainedPair, anent, ent);
+ RWStepKinematics_RWUnconstrainedPair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 788:
+ {
+ DeclareAndCast(StepKinematics_UnconstrainedPairValue, anent, ent);
+ RWStepKinematics_RWUnconstrainedPairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 789:
+ {
+ DeclareAndCast(StepKinematics_UniversalPair, anent, ent);
+ RWStepKinematics_RWUniversalPair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 790:
+ {
+ DeclareAndCast(StepKinematics_UniversalPairValue, anent, ent);
+ RWStepKinematics_RWUniversalPairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 791:
+ {
+ DeclareAndCast(StepKinematics_UniversalPairWithRange, anent, ent);
+ RWStepKinematics_RWUniversalPairWithRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 792:
+ {
+ DeclareAndCast(StepKinematics_PairRepresentationRelationship, anent, ent);
+ RWStepKinematics_RWPairRepresentationRelationship tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 793:
+ {
+ DeclareAndCast(StepKinematics_RigidLinkRepresentation, anent, ent);
+ RWStepKinematics_RWRigidLinkRepresentation tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 794:
+ {
+ DeclareAndCast(StepKinematics_KinematicTopologyDirectedStructure, anent, ent);
+ RWStepKinematics_RWKinematicTopologyDirectedStructure tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 795:
+ {
+ DeclareAndCast(StepKinematics_KinematicTopologyNetworkStructure, anent, ent);
+ RWStepKinematics_RWKinematicTopologyNetworkStructure tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 796:
+ {
+ DeclareAndCast(StepKinematics_LinearFlexibleAndPinionPair, anent, ent);
+ RWStepKinematics_RWLinearFlexibleAndPinionPair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 797:
+ {
+ DeclareAndCast(StepKinematics_LinearFlexibleAndPlanarCurvePair, anent, ent);
+ RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 798:
+ {
+ DeclareAndCast(StepKinematics_LinearFlexibleLinkRepresentation, anent, ent);
+ RWStepKinematics_RWLinearFlexibleLinkRepresentation tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 800:
+ {
+ DeclareAndCast(StepKinematics_ActuatedKinPairAndOrderKinPair, anent, ent);
+ RWStepKinematics_RWActuatedKinPairAndOrderKinPair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 801:
+ {
+ DeclareAndCast(StepKinematics_MechanismStateRepresentation, anent, ent);
+ RWStepKinematics_RWMechanismStateRepresentation tool;
+ tool.Share(anent, iter);
+ }
+ break;
+
default : break;
}
}
case 723:
ent = new StepVisual_SurfaceStyleRenderingWithProperties;
break;
+ case 724:
+ ent = new StepRepr_RepresentationContextReference;
+ break;
+ case 725:
+ ent = new StepRepr_RepresentationReference;
+ break;
+ case 726:
+ ent = new StepGeom_SuParameters;
+ break;
+ case 727:
+ ent = new StepKinematics_RotationAboutDirection;
+ break;
+ case 728:
+ ent = new StepKinematics_KinematicJoint;
+ break;
+ case 729:
+ ent = new StepKinematics_ActuatedKinematicPair;
+ break;
+ case 730:
+ ent = new StepKinematics_ContextDependentKinematicLinkRepresentation;
+ break;
+ case 731:
+ ent = new StepKinematics_CylindricalPair;
+ break;
+ case 732:
+ ent = new StepKinematics_CylindricalPairValue;
+ break;
+ case 733:
+ ent = new StepKinematics_CylindricalPairWithRange;
+ break;
+ case 734:
+ ent = new StepKinematics_FullyConstrainedPair;
+ break;
+ case 735:
+ ent = new StepKinematics_GearPair;
+ break;
+ case 736:
+ ent = new StepKinematics_GearPairValue;
+ break;
+ case 737:
+ ent = new StepKinematics_GearPairWithRange;
+ break;
+ case 738:
+ ent = new StepKinematics_HomokineticPair;
+ break;
+ case 739:
+ ent = new StepKinematics_KinematicLink;
+ break;
+ case 740:
+ ent = new StepKinematics_KinematicLinkRepresentationAssociation;
+ break;
+ case 741:
+ ent = new StepKinematics_KinematicPropertyMechanismRepresentation;
+ break;
+ case 742:
+ ent = new StepKinematics_KinematicTopologyStructure;
+ break;
+ case 743:
+ ent = new StepKinematics_LowOrderKinematicPair;
+ break;
+ case 744:
+ ent = new StepKinematics_LowOrderKinematicPairValue;
+ break;
+ case 745:
+ ent = new StepKinematics_LowOrderKinematicPairWithRange;
+ break;
+ case 746:
+ ent = new StepKinematics_MechanismRepresentation;
+ break;
+ case 747:
+ ent = new StepKinematics_OrientedJoint;
+ break;
+ case 748:
+ ent = new StepKinematics_PlanarCurvePair;
+ break;
+ case 749:
+ ent = new StepKinematics_PlanarCurvePairRange;
+ break;
+ case 750:
+ ent = new StepKinematics_PlanarPair;
+ break;
+ case 751:
+ ent = new StepKinematics_PlanarPairValue;
+ break;
+ case 752:
+ ent = new StepKinematics_PlanarPairWithRange;
+ break;
+ case 753:
+ ent = new StepKinematics_PointOnPlanarCurvePair;
+ break;
+ case 754:
+ ent = new StepKinematics_PointOnPlanarCurvePairValue;
+ break;
+ case 755:
+ ent = new StepKinematics_PointOnPlanarCurvePairWithRange;
+ break;
+ case 756:
+ ent = new StepKinematics_PointOnSurfacePair;
+ break;
+ case 757:
+ ent = new StepKinematics_PointOnSurfacePairValue;
+ break;
+ case 758:
+ ent = new StepKinematics_PointOnSurfacePairWithRange;
+ break;
+ case 759:
+ ent = new StepKinematics_PrismaticPair;
+ break;
+ case 760:
+ ent = new StepKinematics_PrismaticPairValue;
+ break;
+ case 761:
+ ent = new StepKinematics_PrismaticPairWithRange;
+ break;
+ case 762:
+ ent = new StepKinematics_ProductDefinitionKinematics;
+ break;
+ case 763:
+ ent = new StepKinematics_ProductDefinitionRelationshipKinematics;
+ break;
+ case 764:
+ ent = new StepKinematics_RackAndPinionPair;
+ break;
+ case 765:
+ ent = new StepKinematics_RackAndPinionPairValue;
+ break;
+ case 766:
+ ent = new StepKinematics_RackAndPinionPairWithRange;
+ break;
+ case 767:
+ ent = new StepKinematics_RevolutePair;
+ break;
+ case 768:
+ ent = new StepKinematics_RevolutePairValue;
+ break;
+ case 769:
+ ent = new StepKinematics_RevolutePairWithRange;
+ break;
+ case 770:
+ ent = new StepKinematics_RollingCurvePair;
+ break;
+ case 771:
+ ent = new StepKinematics_RollingCurvePairValue;
+ break;
+ case 772:
+ ent = new StepKinematics_RollingSurfacePair;
+ break;
+ case 773:
+ ent = new StepKinematics_RollingSurfacePairValue;
+ break;
+ case 774:
+ ent = new StepKinematics_ScrewPair;
+ break;
+ case 775:
+ ent = new StepKinematics_ScrewPairValue;
+ break;
+ case 776:
+ ent = new StepKinematics_ScrewPairWithRange;
+ break;
+ case 777:
+ ent = new StepKinematics_SlidingCurvePair;
+ break;
+ case 778:
+ ent = new StepKinematics_SlidingCurvePairValue;
+ break;
+ case 779:
+ ent = new StepKinematics_SlidingSurfacePair;
+ break;
+ case 780:
+ ent = new StepKinematics_SlidingSurfacePairValue;
+ break;
+ case 781:
+ ent = new StepKinematics_SphericalPair;
+ break;
+ case 782:
+ ent = new StepKinematics_SphericalPairValue;
+ break;
+ case 783:
+ ent = new StepKinematics_SphericalPairWithPin;
+ break;
+ case 784:
+ ent = new StepKinematics_SphericalPairWithPinAndRange;
+ break;
+ case 785:
+ ent = new StepKinematics_SphericalPairWithRange;
+ break;
+ case 786:
+ ent = new StepKinematics_SurfacePairWithRange;
+ break;
+ case 787:
+ ent = new StepKinematics_UnconstrainedPair;
+ break;
+ case 788:
+ ent = new StepKinematics_UnconstrainedPairValue;
+ break;
+ case 789:
+ ent = new StepKinematics_UniversalPair;
+ break;
+ case 790:
+ ent = new StepKinematics_UniversalPairValue;
+ break;
+ case 791:
+ ent = new StepKinematics_UniversalPairWithRange;
+ break;
+ case 792:
+ ent = new StepKinematics_PairRepresentationRelationship;
+ break;
+ case 793:
+ ent = new StepKinematics_RigidLinkRepresentation;
+ break;
+ case 794:
+ ent = new StepKinematics_KinematicTopologyDirectedStructure;
+ break;
+ case 795:
+ ent = new StepKinematics_KinematicTopologyNetworkStructure;
+ break;
+ case 796:
+ ent = new StepKinematics_LinearFlexibleAndPinionPair;
+ break;
+ case 797:
+ ent = new StepKinematics_LinearFlexibleAndPlanarCurvePair;
+ break;
+ case 798:
+ ent = new StepKinematics_LinearFlexibleLinkRepresentation;
+ break;
+ case 800:
+ ent = new StepKinematics_ActuatedKinPairAndOrderKinPair;
+ break;
+ case 801:
+ ent = new StepKinematics_MechanismStateRepresentation;
+ break;
+
default:
return Standard_False;
}
case 721:
case 722:
case 723: return catdr;
-
+ case 724: return cataux;
+ case 725: return cataux;
+ case 726: return cataux;
+ case 727: return cataux;
+ case 728: return cataux;
+ case 729: return cataux;
+ case 730: return cataux;
+ case 731: return cataux;
+ case 732: return cataux;
+ case 733: return cataux;
+ case 734: return cataux;
+ case 735: return cataux;
+ case 736: return cataux;
+ case 737: return cataux;
+ case 738: return cataux;
+ case 739: return cataux;
+ case 740: return cataux;
+ case 741: return cataux;
+ case 742: return cataux;
+ case 743: return cataux;
+ case 744: return cataux;
+ case 745: return cataux;
+ case 746: return cataux;
+ case 747: return cataux;
+ case 748: return cataux;
+ case 749: return cataux;
+ case 750: return cataux;
+ case 751: return cataux;
+ case 752: return cataux;
+ case 753: return cataux;
+ case 754: return cataux;
+ case 755: return cataux;
+ case 756: return cataux;
+ case 757: return cataux;
+ case 758: return cataux;
+ case 759: return cataux;
+ case 760: return cataux;
+ case 761: return cataux;
+ case 762: return cataux;
+ case 763: return cataux;
+ case 764: return cataux;
+ case 765: return cataux;
+ case 766: return cataux;
+ case 767: return cataux;
+ case 768: return cataux;
+ case 769: return cataux;
+ case 770: return cataux;
+ case 771: return cataux;
+ case 772: return cataux;
+ case 773: return cataux;
+ case 774: return cataux;
+ case 775: return cataux;
+ case 776: return cataux;
+ case 777: return cataux;
+ case 778: return cataux;
+ case 779: return cataux;
+ case 780: return cataux;
+ case 781: return cataux;
+ case 782: return cataux;
+ case 783: return cataux;
+ case 784: return cataux;
+ case 785: return cataux;
+ case 786: return cataux;
+ case 787: return cataux;
+ case 788: return cataux;
+ case 789: return cataux;
+ case 790: return cataux;
+ case 791: return cataux;
+ case 792: return cataux;
+ case 793: return cataux;
+ case 794: return cataux;
+ case 795: return cataux;
+ case 796: return cataux;
+ case 797: return cataux;
+ case 798: return cataux;
+ case 800: return catsh;
+ case 801: return cataux;
default : break;
}
return 0;
#include <RWStepVisual_RWSurfaceStyleRendering.hxx>
#include <RWStepVisual_RWSurfaceStyleRenderingWithProperties.hxx>
+// Added for kinematics implementation
+#include <RWStepGeom_RWSuParameters.hxx>
+#include <RWStepKinematics_RWActuatedKinPairAndOrderKinPair.hxx>
+#include <RWStepKinematics_RWActuatedKinematicPair.hxx>
+#include <RWStepKinematics_RWContextDependentKinematicLinkRepresentation.hxx>
+#include <RWStepKinematics_RWCylindricalPair.hxx>
+#include <RWStepKinematics_RWCylindricalPairValue.hxx>
+#include <RWStepKinematics_RWCylindricalPairWithRange.hxx>
+#include <RWStepKinematics_RWFullyConstrainedPair.hxx>
+#include <RWStepKinematics_RWGearPair.hxx>
+#include <RWStepKinematics_RWGearPairValue.hxx>
+#include <RWStepKinematics_RWGearPairWithRange.hxx>
+#include <RWStepKinematics_RWHomokineticPair.hxx>
+#include <RWStepKinematics_RWKinematicJoint.hxx>
+#include <RWStepKinematics_RWKinematicLink.hxx>
+#include <RWStepKinematics_RWKinematicLinkRepresentationAssociation.hxx>
+#include <RWStepKinematics_RWKinematicPropertyMechanismRepresentation.hxx>
+#include <RWStepKinematics_RWKinematicTopologyDirectedStructure.hxx>
+#include <RWStepKinematics_RWKinematicTopologyNetworkStructure.hxx>
+#include <RWStepKinematics_RWKinematicTopologyStructure.hxx>
+#include <RWStepKinematics_RWLinearFlexibleAndPinionPair.hxx>
+#include <RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair.hxx>
+#include <RWStepKinematics_RWLinearFlexibleLinkRepresentation.hxx>
+#include <RWStepKinematics_RWLowOrderKinematicPair.hxx>
+#include <RWStepKinematics_RWLowOrderKinematicPairValue.hxx>
+#include <RWStepKinematics_RWLowOrderKinematicPairWithRange.hxx>
+#include <RWStepKinematics_RWMechanismRepresentation.hxx>
+#include <RWStepKinematics_RWMechanismStateRepresentation.hxx>
+#include <RWStepKinematics_RWOrientedJoint.hxx>
+#include <RWStepKinematics_RWPairRepresentationRelationship.hxx>
+#include <RWStepKinematics_RWPlanarCurvePair.hxx>
+#include <RWStepKinematics_RWPlanarCurvePairRange.hxx>
+#include <RWStepKinematics_RWPlanarPair.hxx>
+#include <RWStepKinematics_RWPlanarPairValue.hxx>
+#include <RWStepKinematics_RWPlanarPairWithRange.hxx>
+#include <RWStepKinematics_RWPointOnPlanarCurvePair.hxx>
+#include <RWStepKinematics_RWPointOnPlanarCurvePairValue.hxx>
+#include <RWStepKinematics_RWPointOnPlanarCurvePairWithRange.hxx>
+#include <RWStepKinematics_RWPointOnSurfacePair.hxx>
+#include <RWStepKinematics_RWPointOnSurfacePairValue.hxx>
+#include <RWStepKinematics_RWPointOnSurfacePairWithRange.hxx>
+#include <RWStepKinematics_RWPrismaticPair.hxx>
+#include <RWStepKinematics_RWPrismaticPairValue.hxx>
+#include <RWStepKinematics_RWPrismaticPairWithRange.hxx>
+#include <RWStepKinematics_RWProductDefinitionKinematics.hxx>
+#include <RWStepKinematics_RWProductDefinitionRelationshipKinematics.hxx>
+#include <RWStepKinematics_RWRackAndPinionPair.hxx>
+#include <RWStepKinematics_RWRackAndPinionPairValue.hxx>
+#include <RWStepKinematics_RWRackAndPinionPairWithRange.hxx>
+#include <RWStepKinematics_RWRevolutePair.hxx>
+#include <RWStepKinematics_RWRevolutePairValue.hxx>
+#include <RWStepKinematics_RWRevolutePairWithRange.hxx>
+#include <RWStepKinematics_RWRigidLinkRepresentation.hxx>
+#include <RWStepKinematics_RWRollingCurvePair.hxx>
+#include <RWStepKinematics_RWRollingCurvePairValue.hxx>
+#include <RWStepKinematics_RWRollingSurfacePair.hxx>
+#include <RWStepKinematics_RWRollingSurfacePairValue.hxx>
+#include <RWStepKinematics_RWRotationAboutDirection.hxx>
+#include <RWStepKinematics_RWScrewPair.hxx>
+#include <RWStepKinematics_RWScrewPairValue.hxx>
+#include <RWStepKinematics_RWScrewPairWithRange.hxx>
+#include <RWStepKinematics_RWSlidingCurvePair.hxx>
+#include <RWStepKinematics_RWSlidingCurvePairValue.hxx>
+#include <RWStepKinematics_RWSlidingSurfacePair.hxx>
+#include <RWStepKinematics_RWSlidingSurfacePairValue.hxx>
+#include <RWStepKinematics_RWSphericalPair.hxx>
+#include <RWStepKinematics_RWSphericalPairValue.hxx>
+#include <RWStepKinematics_RWSphericalPairWithPin.hxx>
+#include <RWStepKinematics_RWSphericalPairWithPinAndRange.hxx>
+#include <RWStepKinematics_RWSphericalPairWithRange.hxx>
+#include <RWStepKinematics_RWSurfacePairWithRange.hxx>
+#include <RWStepKinematics_RWUnconstrainedPair.hxx>
+#include <RWStepKinematics_RWUnconstrainedPairValue.hxx>
+#include <RWStepKinematics_RWUniversalPair.hxx>
+#include <RWStepKinematics_RWUniversalPairValue.hxx>
+#include <RWStepKinematics_RWUniversalPairWithRange.hxx>
+#include <RWStepRepr_RWRepresentationContextReference.hxx>
+#include <RWStepRepr_RWRepresentationReference.hxx>
+
+#include <StepGeom_SuParameters.hxx>
+#include <StepKinematics_ActuatedKinPairAndOrderKinPair.hxx>
+#include <StepKinematics_ActuatedKinematicPair.hxx>
+#include <StepKinematics_ContextDependentKinematicLinkRepresentation.hxx>
+#include <StepKinematics_CylindricalPair.hxx>
+#include <StepKinematics_CylindricalPairValue.hxx>
+#include <StepKinematics_CylindricalPairWithRange.hxx>
+#include <StepKinematics_FullyConstrainedPair.hxx>
+#include <StepKinematics_GearPair.hxx>
+#include <StepKinematics_GearPairValue.hxx>
+#include <StepKinematics_GearPairWithRange.hxx>
+#include <StepKinematics_HomokineticPair.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepKinematics_KinematicLink.hxx>
+#include <StepKinematics_KinematicLinkRepresentationAssociation.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <StepKinematics_KinematicPropertyMechanismRepresentation.hxx>
+#include <StepKinematics_KinematicTopologyDirectedStructure.hxx>
+#include <StepKinematics_KinematicTopologyNetworkStructure.hxx>
+#include <StepKinematics_KinematicTopologyStructure.hxx>
+#include <StepKinematics_LinearFlexibleAndPinionPair.hxx>
+#include <StepKinematics_LinearFlexibleAndPlanarCurvePair.hxx>
+#include <StepKinematics_LinearFlexibleLinkRepresentation.hxx>
+#include <StepKinematics_LowOrderKinematicPair.hxx>
+#include <StepKinematics_LowOrderKinematicPairValue.hxx>
+#include <StepKinematics_LowOrderKinematicPairWithRange.hxx>
+#include <StepKinematics_MechanismRepresentation.hxx>
+#include <StepKinematics_MechanismStateRepresentation.hxx>
+#include <StepKinematics_OrientedJoint.hxx>
+#include <StepKinematics_PairRepresentationRelationship.hxx>
+#include <StepKinematics_PlanarCurvePair.hxx>
+#include <StepKinematics_PlanarCurvePairRange.hxx>
+#include <StepKinematics_PlanarPair.hxx>
+#include <StepKinematics_PlanarPairValue.hxx>
+#include <StepKinematics_PlanarPairWithRange.hxx>
+#include <StepKinematics_PointOnPlanarCurvePair.hxx>
+#include <StepKinematics_PointOnPlanarCurvePairValue.hxx>
+#include <StepKinematics_PointOnPlanarCurvePairWithRange.hxx>
+#include <StepKinematics_PointOnSurfacePair.hxx>
+#include <StepKinematics_PointOnSurfacePairValue.hxx>
+#include <StepKinematics_PointOnSurfacePairWithRange.hxx>
+#include <StepKinematics_PrismaticPair.hxx>
+#include <StepKinematics_PrismaticPairValue.hxx>
+#include <StepKinematics_PrismaticPairWithRange.hxx>
+#include <StepKinematics_ProductDefinitionKinematics.hxx>
+#include <StepKinematics_ProductDefinitionRelationshipKinematics.hxx>
+#include <StepKinematics_RackAndPinionPair.hxx>
+#include <StepKinematics_RackAndPinionPairValue.hxx>
+#include <StepKinematics_RackAndPinionPairWithRange.hxx>
+#include <StepKinematics_RevolutePair.hxx>
+#include <StepKinematics_RevolutePairValue.hxx>
+#include <StepKinematics_RevolutePairWithRange.hxx>
+#include <StepKinematics_RigidLinkRepresentation.hxx>
+#include <StepKinematics_RollingCurvePair.hxx>
+#include <StepKinematics_RollingCurvePairValue.hxx>
+#include <StepKinematics_RollingSurfacePair.hxx>
+#include <StepKinematics_RollingSurfacePairValue.hxx>
+#include <StepKinematics_RotationAboutDirection.hxx>
+#include <StepKinematics_ScrewPair.hxx>
+#include <StepKinematics_ScrewPairValue.hxx>
+#include <StepKinematics_ScrewPairWithRange.hxx>
+#include <StepKinematics_SlidingCurvePair.hxx>
+#include <StepKinematics_SlidingCurvePairValue.hxx>
+#include <StepKinematics_SlidingSurfacePair.hxx>
+#include <StepKinematics_SlidingSurfacePairValue.hxx>
+#include <StepKinematics_SphericalPair.hxx>
+#include <StepKinematics_SphericalPairValue.hxx>
+#include <StepKinematics_SphericalPairWithPin.hxx>
+#include <StepKinematics_SphericalPairWithPinAndRange.hxx>
+#include <StepKinematics_SphericalPairWithRange.hxx>
+#include <StepKinematics_SurfacePairWithRange.hxx>
+#include <StepKinematics_UnconstrainedPair.hxx>
+#include <StepKinematics_UnconstrainedPairValue.hxx>
+#include <StepKinematics_UniversalPair.hxx>
+#include <StepKinematics_UniversalPairValue.hxx>
+#include <StepKinematics_UniversalPairWithRange.hxx>
+#include <StepRepr_RepresentationContextReference.hxx>
+#include <StepRepr_RepresentationReference.hxx>
+
// -- General Declarations (Recognize, StepType) ---
static TCollection_AsciiString PasReco("?");
static TCollection_AsciiString Reco_SurfaceStyleRendering("SURFACE_STYLE_RENDERING");
static TCollection_AsciiString Reco_SurfaceStyleRenderingWithProperties("SURFACE_STYLE_RENDERING_WITH_PROPERTIES");
+static TCollection_AsciiString Reco_RepresentationContextReference("REPRESENTATION_CONTEXT_REFERENCE");
+static TCollection_AsciiString Reco_RepresentationReference("REPRESENTATION_REFERENCE");
+static TCollection_AsciiString Reco_SuParameters("SU_PARAMETERS");
+static TCollection_AsciiString Reco_RotationAboutDirection("ROTATION_ABOUT_DIRECTION");
+static TCollection_AsciiString Reco_KinematicJoint("KINEMATIC_JOINT");
+static TCollection_AsciiString Reco_ActuatedKinematicPair("ACTUATED_KINEMATIC_PAIR");
+static TCollection_AsciiString Reco_ContextDependentKinematicLinkRepresentation("CONTEXT_DEPENDENT_KINEMATIC_LINK_REPRESENTATION");
+static TCollection_AsciiString Reco_CylindricalPair("CYLINDRICAL_PAIR");
+static TCollection_AsciiString Reco_CylindricalPairValue("CYLINDRICAL_PAIR_VALUE");
+static TCollection_AsciiString Reco_CylindricalPairWithRange("CYLINDRICAL_PAIR_WITH_RANGE");
+static TCollection_AsciiString Reco_FullyConstrainedPair("FULLY_CONSTRAINED_PAIR");
+static TCollection_AsciiString Reco_GearPair("GEAR_PAIR");
+static TCollection_AsciiString Reco_GearPairValue("GEAR_PAIR_VALUE");
+static TCollection_AsciiString Reco_GearPairWithRange("GEAR_PAIR_WITH_RANGE");
+static TCollection_AsciiString Reco_HomokineticPair("HOMOKINETIC_PAIR");
+static TCollection_AsciiString Reco_KinematicLink("KINEMATIC_LINK");
+static TCollection_AsciiString Reco_KinematicLinkRepresentationAssociation("KINEMATIC_LINK_REPRESENTATION_ASSOCIATION");
+static TCollection_AsciiString Reco_KinematicPropertyMechanismRepresentation("KINEMATIC_PROPERTY_MECHANISM_REPRESENTATION");
+static TCollection_AsciiString Reco_KinematicTopologyDirectedStructure("KINEMATIC_TOPOLOGY_DIRECTED_STRUCTURE");
+static TCollection_AsciiString Reco_KinematicTopologyNetworkStructure("KINEMATIC_TOPOLOGY_NETWORK_STRUCTURE");
+static TCollection_AsciiString Reco_KinematicTopologyStructure("KINEMATIC_TOPOLOGY_STRUCTURE");
+static TCollection_AsciiString Reco_LinearFlexibleAndPinionPair("LINEAR_FLEXIBLE_AND_PINION_PAIR");
+static TCollection_AsciiString Reco_LinearFlexibleAndPlanarCurvePair("LINEAR_FLEXIBLE_AND_PLANAR_CURVE_PAIR");
+static TCollection_AsciiString Reco_LinearFlexibleLinkRepresentation("LINEAR_FLEXIBLE_LINK_REPRESENTATION");
+static TCollection_AsciiString Reco_LowOrderKinematicPair("LOW_ORDER_KINEMATIC_PAIR");
+static TCollection_AsciiString Reco_LowOrderKinematicPairValue("LOW_ORDER_KINEMATIC_PAIR_VALUE");
+static TCollection_AsciiString Reco_LowOrderKinematicPairWithRange("LOW_ORDER_KINEMATIC_PAIR_WITH_RANGE");
+static TCollection_AsciiString Reco_MechanismRepresentation("MECHANISM_REPRESENTATION");
+static TCollection_AsciiString Reco_OrientedJoint("ORIENTED_JOINT");
+static TCollection_AsciiString Reco_PairRepresentationRelationship("PAIR_REPRESENTATION_RELATIONSHIP");
+static TCollection_AsciiString Reco_PlanarCurvePair("PLANAR_CURVE_PAIR");
+static TCollection_AsciiString Reco_PlanarCurvePairRange("PLANAR_CURVE_PAIR_RANGE");
+static TCollection_AsciiString Reco_PlanarPair("PLANAR_PAIR");
+static TCollection_AsciiString Reco_PlanarPairValue("PLANAR_PAIR_VALUE");
+static TCollection_AsciiString Reco_PlanarPairWithRange("PLANAR_PAIR_WITH_RANGE");
+static TCollection_AsciiString Reco_PointOnPlanarCurvePair("POINT_ON_PLANAR_CURVE_PAIR");
+static TCollection_AsciiString Reco_PointOnPlanarCurvePairValue("POINT_ON_PLANAR_CURVE_PAIR_VALUE");
+static TCollection_AsciiString Reco_PointOnPlanarCurvePairWithRange("POINT_ON_PLANAR_CURVE_PAIR_WITH_RANGE");
+static TCollection_AsciiString Reco_PointOnSurfacePair("POINT_ON_SURFACE_PAIR");
+static TCollection_AsciiString Reco_PointOnSurfacePairValue("POINT_ON_SURFACE_PAIR_VALUE");
+static TCollection_AsciiString Reco_PointOnSurfacePairWithRange("POINT_ON_SURFACE_PAIR_WITH_RANGE");
+static TCollection_AsciiString Reco_PrismaticPair("PRISMATIC_PAIR");
+static TCollection_AsciiString Reco_PrismaticPairValue("PRISMATIC_PAIR_VALUE");
+static TCollection_AsciiString Reco_PrismaticPairWithRange("PRISMATIC_PAIR_WITH_RANGE");
+static TCollection_AsciiString Reco_ProductDefinitionKinematics("PRODUCT_DEFINITION_KINEMATICS");
+static TCollection_AsciiString Reco_ProductDefinitionRelationshipKinematics("PRODUCT_DEFINITION_RELATIONSHIP_KINEMATICS");
+static TCollection_AsciiString Reco_RackAndPinionPair("RACK_AND_PINION_PAIR");
+static TCollection_AsciiString Reco_RackAndPinionPairValue("RACK_AND_PINION_PAIR_VALUE");
+static TCollection_AsciiString Reco_RackAndPinionPairWithRange("RACK_AND_PINION_PAIR_WITH_RANGE");
+static TCollection_AsciiString Reco_RevolutePair("REVOLUTE_PAIR");
+static TCollection_AsciiString Reco_RevolutePairValue("REVOLUTE_PAIR_VALUE");
+static TCollection_AsciiString Reco_RevolutePairWithRange("REVOLUTE_PAIR_WITH_RANGE");
+static TCollection_AsciiString Reco_RigidLinkRepresentation("RIGID_LINK_REPRESENTATION");
+static TCollection_AsciiString Reco_RollingCurvePair("ROLLING_CURVE_PAIR");
+static TCollection_AsciiString Reco_RollingCurvePairValue("ROLLING_CURVE_PAIR_VALUE");
+static TCollection_AsciiString Reco_RollingSurfacePair("ROLLING_SURFACE_PAIR");
+static TCollection_AsciiString Reco_RollingSurfacePairValue("ROLLING_SURFACE_PAIR_VALUE");
+static TCollection_AsciiString Reco_ScrewPair("SCREW_PAIR");
+static TCollection_AsciiString Reco_ScrewPairValue("SCREW_PAIR_VALUE");
+static TCollection_AsciiString Reco_ScrewPairWithRange("SCREW_PAIR_WITH_RANGE");
+static TCollection_AsciiString Reco_SlidingCurvePair("SLIDING_CURVE_PAIR");
+static TCollection_AsciiString Reco_SlidingCurvePairValue("SLIDING_CURVE_PAIR_VALUE");
+static TCollection_AsciiString Reco_SlidingSurfacePair("SLIDING_SURFACE_PAIR");
+static TCollection_AsciiString Reco_SlidingSurfacePairValue("SLIDING_SURFACE_PAIR_VALUE");
+static TCollection_AsciiString Reco_SphericalPair("SPHERICAL_PAIR");
+static TCollection_AsciiString Reco_SphericalPairValue("SPHERICAL_PAIR_VALUE");
+static TCollection_AsciiString Reco_SphericalPairWithPin("SPHERICAL_PAIR_WITH_PIN");
+static TCollection_AsciiString Reco_SphericalPairWithPinAndRange("SPHERICAL_PAIR_WITH_PIN_AND_RANGE");
+static TCollection_AsciiString Reco_SphericalPairWithRange("SPHERICAL_PAIR_WITH_RANGE");
+static TCollection_AsciiString Reco_SurfacePairWithRange("SURFACE_PAIR_WITH_RANGE");
+static TCollection_AsciiString Reco_UnconstrainedPair("UNCONSTRAINED_PAIR");
+static TCollection_AsciiString Reco_UnconstrainedPairValue("UNCONSTRAINED_PAIR_VALUE");
+static TCollection_AsciiString Reco_UniversalPair("UNIVERSAL_PAIR");
+static TCollection_AsciiString Reco_UniversalPairValue("UNIVERSAL_PAIR_VALUE");
+static TCollection_AsciiString Reco_UniversalPairWithRange("UNIVERSAL_PAIR_WITH_RANGE");
+static TCollection_AsciiString Reco_KinematicPair("KINEMATIC_PAIR");
+static TCollection_AsciiString Reco_MechanismStateRepresentation("MECHANISM_STATE_REPRESENTATION");
+
// -- Definition of the libraries --
static NCollection_DataMap<TCollection_AsciiString, Standard_Integer> typenums;
typenums.Bind (Reco_SurfaceStyleRendering, 722);
typenums.Bind (Reco_SurfaceStyleRenderingWithProperties, 723);
+ typenums.Bind(Reco_RepresentationContextReference, 724);
+ typenums.Bind(Reco_RepresentationReference, 725);
+ typenums.Bind(Reco_SuParameters, 726);
+ typenums.Bind(Reco_RotationAboutDirection, 727);
+ typenums.Bind(Reco_KinematicJoint, 728);
+ typenums.Bind(Reco_ActuatedKinematicPair, 729);
+ typenums.Bind(Reco_ContextDependentKinematicLinkRepresentation, 730);
+ typenums.Bind(Reco_CylindricalPair, 731);
+ typenums.Bind(Reco_CylindricalPairValue, 732);
+ typenums.Bind(Reco_CylindricalPairWithRange, 733);
+ typenums.Bind(Reco_FullyConstrainedPair, 734);
+ typenums.Bind(Reco_GearPair, 735);
+ typenums.Bind(Reco_GearPairValue, 736);
+ typenums.Bind(Reco_GearPairWithRange, 737);
+ typenums.Bind(Reco_HomokineticPair, 738);
+ typenums.Bind(Reco_KinematicLink, 739);
+ typenums.Bind(Reco_KinematicLinkRepresentationAssociation, 740);
+ typenums.Bind(Reco_KinematicPropertyMechanismRepresentation, 741);
+ typenums.Bind(Reco_KinematicTopologyStructure, 742);
+ typenums.Bind(Reco_LowOrderKinematicPair, 743);
+ typenums.Bind(Reco_LowOrderKinematicPairValue, 744);
+ typenums.Bind(Reco_LowOrderKinematicPairWithRange, 745);
+ typenums.Bind(Reco_MechanismRepresentation, 746);
+ typenums.Bind(Reco_OrientedJoint, 747);
+ typenums.Bind(Reco_PlanarCurvePair, 748);
+ typenums.Bind(Reco_PlanarCurvePairRange, 749);
+ typenums.Bind(Reco_PlanarPair, 750);
+ typenums.Bind(Reco_PlanarPairValue, 751);
+ typenums.Bind(Reco_PlanarPairWithRange, 752);
+ typenums.Bind(Reco_PointOnPlanarCurvePair, 753);
+ typenums.Bind(Reco_PointOnPlanarCurvePairValue, 754);
+ typenums.Bind(Reco_PointOnPlanarCurvePairWithRange, 755);
+ typenums.Bind(Reco_PointOnSurfacePair, 756);
+ typenums.Bind(Reco_PointOnSurfacePairValue, 757);
+ typenums.Bind(Reco_PointOnSurfacePairWithRange, 758);
+ typenums.Bind(Reco_PrismaticPair, 759);
+ typenums.Bind(Reco_PrismaticPairValue, 760);
+ typenums.Bind(Reco_PrismaticPairWithRange, 761);
+ typenums.Bind(Reco_ProductDefinitionKinematics, 762);
+ typenums.Bind(Reco_ProductDefinitionRelationshipKinematics, 763);
+ typenums.Bind(Reco_RackAndPinionPair, 764);
+ typenums.Bind(Reco_RackAndPinionPairValue, 765);
+ typenums.Bind(Reco_RackAndPinionPairWithRange, 766);
+ typenums.Bind(Reco_RevolutePair, 767);
+ typenums.Bind(Reco_RevolutePairValue, 768);
+ typenums.Bind(Reco_RevolutePairWithRange, 769);
+ typenums.Bind(Reco_RollingCurvePair, 770);
+ typenums.Bind(Reco_RollingCurvePairValue, 771);
+ typenums.Bind(Reco_RollingSurfacePair, 772);
+ typenums.Bind(Reco_RollingSurfacePairValue, 773);
+ typenums.Bind(Reco_ScrewPair, 774);
+ typenums.Bind(Reco_ScrewPairValue, 775);
+ typenums.Bind(Reco_ScrewPairWithRange, 776);
+ typenums.Bind(Reco_SlidingCurvePair, 777);
+ typenums.Bind(Reco_SlidingCurvePairValue, 778);
+ typenums.Bind(Reco_SlidingSurfacePair, 779);
+ typenums.Bind(Reco_SlidingSurfacePairValue, 780);
+ typenums.Bind(Reco_SphericalPair, 781);
+ typenums.Bind(Reco_SphericalPairValue, 782);
+ typenums.Bind(Reco_SphericalPairWithPin, 783);
+ typenums.Bind(Reco_SphericalPairWithPinAndRange, 784);
+ typenums.Bind(Reco_SphericalPairWithRange, 785);
+ typenums.Bind(Reco_SurfacePairWithRange, 786);
+ typenums.Bind(Reco_UnconstrainedPair, 787);
+ typenums.Bind(Reco_UnconstrainedPairValue, 788);
+ typenums.Bind(Reco_UniversalPair, 789);
+ typenums.Bind(Reco_UniversalPairValue, 790);
+ typenums.Bind(Reco_UniversalPairWithRange, 791);
+ typenums.Bind(Reco_PairRepresentationRelationship, 792);
+ typenums.Bind(Reco_RigidLinkRepresentation, 793);
+ typenums.Bind(Reco_KinematicTopologyDirectedStructure, 794);
+ typenums.Bind(Reco_KinematicTopologyNetworkStructure, 795);
+ typenums.Bind(Reco_LinearFlexibleAndPinionPair, 796);
+ typenums.Bind(Reco_LinearFlexibleAndPlanarCurvePair, 797);
+ typenums.Bind(Reco_LinearFlexibleLinkRepresentation, 798);
+ typenums.Bind(Reco_KinematicPair, 799);
+ typenums.Bind(Reco_MechanismStateRepresentation, 801);
+
+
// SHORT NAMES
// NB : la liste est celle de AP203
// Directement exploite pour les types simples
}
}
- if (NbComp == 7) {
+ if (NbComp == 8)
+ {
+ if ((types(1).IsEqual(StepType(729))) &&
+ (types(2).IsEqual(StepType(144))) &&
+ (types(3).IsEqual(StepType(354))) &&
+ (types(4).IsEqual(StepType(799))) &&
+ (types(5).IsEqual(StepType(743))) &&
+ (((types(6).IsEqual(StepType(759))) &&
+ (types(7).IsEqual(StepType(761)))) ||
+ ((types(6).IsEqual(StepType(731))) &&
+ (types(7).IsEqual(StepType(733)))) ||
+ ((types(6).IsEqual(StepType(767))) &&
+ (types(7).IsEqual(StepType(769)))) ||
+ ((types(6).IsEqual(StepType(789))) &&
+ (types(7).IsEqual(StepType(791)))) ||
+ ((types(6).IsEqual(StepType(781))) &&
+ (types(7).IsEqual(StepType(785)))) ||
+ ((types(6).IsEqual(StepType(783))) &&
+ (types(7).IsEqual(StepType(784))))) &&
+ (types(8).IsEqual(StepType(247)))) {
+ return 800;
+ }
+ }
+ else if (NbComp == 7) {
if ((types(1).IsEqual(StepType(48))) &&
(types(2).IsEqual(StepType(38))) &&
(types(3).IsEqual(StepType(84))) &&
case 722 : return Reco_SurfaceStyleRendering;
case 723 : return Reco_SurfaceStyleRenderingWithProperties;
+ case 724: return Reco_RepresentationContextReference;
+ case 725: return Reco_RepresentationReference;
+ case 726: return Reco_SuParameters;
+ case 727: return Reco_RotationAboutDirection;
+ case 728: return Reco_KinematicJoint;
+ case 729: return Reco_ActuatedKinematicPair;
+ case 730: return Reco_ContextDependentKinematicLinkRepresentation;
+ case 731: return Reco_CylindricalPair;
+ case 732: return Reco_CylindricalPairValue;
+ case 733: return Reco_CylindricalPairWithRange;
+ case 734: return Reco_FullyConstrainedPair;
+ case 735: return Reco_GearPair;
+ case 736: return Reco_GearPairValue;
+ case 737: return Reco_GearPairWithRange;
+ case 738: return Reco_HomokineticPair;
+ case 739: return Reco_KinematicLink;
+ case 740: return Reco_KinematicLinkRepresentationAssociation;
+ case 741: return Reco_KinematicPropertyMechanismRepresentation;
+ case 742: return Reco_KinematicTopologyStructure;
+ case 743: return Reco_LowOrderKinematicPair;
+ case 744: return Reco_LowOrderKinematicPairValue;
+ case 745: return Reco_LowOrderKinematicPairWithRange;
+ case 746: return Reco_MechanismRepresentation;
+ case 747: return Reco_OrientedJoint;
+ case 748: return Reco_PlanarCurvePair;
+ case 749: return Reco_PlanarCurvePairRange;
+ case 750: return Reco_PlanarPair;
+ case 751: return Reco_PlanarPairValue;
+ case 752: return Reco_PlanarPairWithRange;
+ case 753: return Reco_PointOnPlanarCurvePair;
+ case 754: return Reco_PointOnPlanarCurvePairValue;
+ case 755: return Reco_PointOnPlanarCurvePairWithRange;
+ case 756: return Reco_PointOnSurfacePair;
+ case 757: return Reco_PointOnSurfacePairValue;
+ case 758: return Reco_PointOnSurfacePairWithRange;
+ case 759: return Reco_PrismaticPair;
+ case 760: return Reco_PrismaticPairValue;
+ case 761: return Reco_PrismaticPairWithRange;
+ case 762: return Reco_ProductDefinitionKinematics;
+ case 763: return Reco_ProductDefinitionRelationshipKinematics;
+ case 764: return Reco_RackAndPinionPair;
+ case 765: return Reco_RackAndPinionPairValue;
+ case 766: return Reco_RackAndPinionPairWithRange;
+ case 767: return Reco_RevolutePair;
+ case 768: return Reco_RevolutePairValue;
+ case 769: return Reco_RevolutePairWithRange;
+ case 770: return Reco_RollingCurvePair;
+ case 771: return Reco_RollingCurvePairValue;
+ case 772: return Reco_RollingSurfacePair;
+ case 773: return Reco_RollingSurfacePairValue;
+ case 774: return Reco_ScrewPair;
+ case 775: return Reco_ScrewPairValue;
+ case 776: return Reco_ScrewPairWithRange;
+ case 777: return Reco_SlidingCurvePair;
+ case 778: return Reco_SlidingCurvePairValue;
+ case 779: return Reco_SlidingSurfacePair;
+ case 780: return Reco_SlidingSurfacePairValue;
+ case 781: return Reco_SphericalPair;
+ case 782: return Reco_SphericalPairValue;
+ case 783: return Reco_SphericalPairWithPin;
+ case 784: return Reco_SphericalPairWithPinAndRange;
+ case 785: return Reco_SphericalPairWithRange;
+ case 786: return Reco_SurfacePairWithRange;
+ case 787: return Reco_UnconstrainedPair;
+ case 788: return Reco_UnconstrainedPairValue;
+ case 789: return Reco_UniversalPair;
+ case 790: return Reco_UniversalPairValue;
+ case 791: return Reco_UniversalPairWithRange;
+ case 792: return Reco_PairRepresentationRelationship;
+ case 793: return Reco_RigidLinkRepresentation;
+ case 794: return Reco_KinematicTopologyDirectedStructure;
+ case 795: return Reco_KinematicTopologyNetworkStructure;
+ case 796: return Reco_LinearFlexibleAndPinionPair;
+ case 797: return Reco_LinearFlexibleAndPlanarCurvePair;
+ case 798: return Reco_LinearFlexibleLinkRepresentation;
+ case 799: return Reco_KinematicPair;
+ case 801: return Reco_MechanismStateRepresentation;
+
default : return PasReco;
}
}
types.Append (StepType(625));
types.Append (StepType(677));
break;
- default : return Standard_False;
case 698:
types.Append (StepType(671));
types.Append (StepType(470));
types.Append(StepType(247));
types.Append(StepType(270));
break;
+ case 800:
+ types.Append(StepType(729));
+ types.Append(StepType(144));
+ types.Append(StepType(354));
+ types.Append(StepType(799));
+ types.Append(StepType(743));
+ types.Append(StepType(757));
+ types.Append(StepType(759));
+ types.Append(StepType(247));
+ break;
+ default: return Standard_False;
}
return Standard_True;
}
tool.ReadStep(data, num, ach, anent);
}
break;
-
- default:
- ach->AddFail("Type Mismatch when reading - Entity");
+ case 724:
+ {
+ DeclareAndCast(StepRepr_RepresentationContextReference, anent, ent);
+ RWStepRepr_RWRepresentationContextReference tool;
+ tool.ReadStep(data, num, ach, anent);
}
- return;
-}
-
-
-//=======================================================================
-//function : WriteStep
-//purpose : Writing of a file
-//=======================================================================
-
-void RWStepAP214_ReadWriteModule::WriteStep(const Standard_Integer CN,
- StepData_StepWriter& SW,
- const Handle(Standard_Transient)&ent) const
-{
- if (CN == 0) return;
- switch (CN) {
- case 1 :
- {
- DeclareAndCast(StepBasic_Address, anent, ent);
- RWStepBasic_RWAddress tool;
-// if (anent.IsNull()) return;
- tool.WriteStep (SW,anent);
- }
-
- break;
- case 2 :
- {
- DeclareAndCast(StepShape_AdvancedBrepShapeRepresentation, anent, ent);
- RWStepShape_RWAdvancedBrepShapeRepresentation tool;
-// if (anent.IsNull()) return;
- tool.WriteStep (SW,anent);
- }
-
- break;
- case 3 :
- {
- DeclareAndCast(StepShape_AdvancedFace, anent, ent);
- RWStepShape_RWAdvancedFace tool;
-// if (anent.IsNull()) return;
- tool.WriteStep (SW,anent);
- }
-
- break;
- case 4 :
- {
- DeclareAndCast(StepVisual_AnnotationCurveOccurrence, anent, ent);
- RWStepVisual_RWAnnotationCurveOccurrence tool;
- tool.WriteStep (SW,anent);
- }
- break;
- case 5:
+ break;
+ case 725:
{
- DeclareAndCast(StepVisual_AnnotationFillArea, anent, ent);
- RWStepVisual_RWAnnotationFillArea tool;
- tool.WriteStep(SW, anent);
+ DeclareAndCast(StepRepr_RepresentationReference, anent, ent);
+ RWStepRepr_RWRepresentationReference tool;
+ tool.ReadStep(data, num, ach, anent);
}
- break;
- case 6:
+ break;
+ case 726:
{
- DeclareAndCast(StepVisual_AnnotationFillAreaOccurrence, anent, ent);
- RWStepVisual_RWAnnotationFillAreaOccurrence tool;
- tool.WriteStep(SW, anent);
+ DeclareAndCast(StepGeom_SuParameters, anent, ent);
+ RWStepGeom_RWSuParameters tool;
+ tool.ReadStep(data, num, ach, anent);
}
- break;
- case 7 :
- {
- DeclareAndCast(StepVisual_AnnotationOccurrence, anent, ent);
- RWStepVisual_RWAnnotationOccurrence tool;
- tool.WriteStep (SW,anent);
- }
-
- break;
- case 11 :
- {
- DeclareAndCast(StepRepr_MappedItem, anent, ent);
- RWStepRepr_RWMappedItem tool;
-// if (anent.IsNull()) return;
- tool.WriteStep (SW,anent);
- }
-
- break;
- case 12 :
- {
- DeclareAndCast(StepVisual_StyledItem, anent, ent);
- RWStepVisual_RWStyledItem tool;
-// if (anent.IsNull()) return;
- tool.WriteStep (SW,anent);
- }
-
- break;
- case 13 :
- {
- DeclareAndCast(StepBasic_ApplicationContext, anent, ent);
- RWStepBasic_RWApplicationContext tool;
-// if (anent.IsNull()) return;
- tool.WriteStep (SW,anent);
- }
-
- break;
- case 14 :
- {
- DeclareAndCast(StepBasic_ApplicationContextElement, anent, ent);
- RWStepBasic_RWApplicationContextElement tool;
-// if (anent.IsNull()) return;
- tool.WriteStep (SW,anent);
- }
-
- break;
- case 15 :
- {
- DeclareAndCast(StepBasic_ApplicationProtocolDefinition, anent, ent);
- RWStepBasic_RWApplicationProtocolDefinition tool;
-// if (anent.IsNull()) return;
- tool.WriteStep (SW,anent);
- }
-
- break;
- case 16 :
- {
- DeclareAndCast(StepBasic_Approval, anent, ent);
- RWStepBasic_RWApproval tool;
-// if (anent.IsNull()) return;
- tool.WriteStep (SW,anent);
- }
-
- break;
- case 18 :
- {
- DeclareAndCast(StepBasic_ApprovalPersonOrganization, anent, ent);
- RWStepBasic_RWApprovalPersonOrganization tool;
-// if (anent.IsNull()) return;
- tool.WriteStep (SW,anent);
- }
-
- break;
- case 19 :
- {
- DeclareAndCast(StepBasic_ApprovalRelationship, anent, ent);
- RWStepBasic_RWApprovalRelationship tool;
-// if (anent.IsNull()) return;
- tool.WriteStep (SW,anent);
- }
-
- break;
- case 20 :
- {
- DeclareAndCast(StepBasic_ApprovalRole, anent, ent);
- RWStepBasic_RWApprovalRole tool;
-// if (anent.IsNull()) return;
- tool.WriteStep (SW,anent);
- }
-
- break;
- case 21 :
- {
- DeclareAndCast(StepBasic_ApprovalStatus, anent, ent);
- RWStepBasic_RWApprovalStatus tool;
-// if (anent.IsNull()) return;
- tool.WriteStep (SW,anent);
- }
-
- break;
- case 22 :
- {
- DeclareAndCast(StepVisual_AreaInSet, anent, ent);
- RWStepVisual_RWAreaInSet tool;
-// if (anent.IsNull()) return;
- tool.WriteStep (SW,anent);
- }
-
- break;
- case 23 :
- {
- DeclareAndCast(StepAP214_AutoDesignActualDateAndTimeAssignment, anent, ent);
- RWStepAP214_RWAutoDesignActualDateAndTimeAssignment tool;
-// if (anent.IsNull()) return;
- tool.WriteStep (SW,anent);
- }
-
- break;
- case 24 :
- {
- DeclareAndCast(StepAP214_AutoDesignActualDateAssignment, anent, ent);
- RWStepAP214_RWAutoDesignActualDateAssignment tool;
-// if (anent.IsNull()) return;
- tool.WriteStep (SW,anent);
- }
-
- break;
- case 25 :
- {
- DeclareAndCast(StepAP214_AutoDesignApprovalAssignment, anent, ent);
- RWStepAP214_RWAutoDesignApprovalAssignment tool;
-// if (anent.IsNull()) return;
- tool.WriteStep (SW,anent);
- }
-
- break;
- case 26 :
- {
- DeclareAndCast(StepAP214_AutoDesignDateAndPersonAssignment, anent, ent);
- RWStepAP214_RWAutoDesignDateAndPersonAssignment tool;
-// if (anent.IsNull()) return;
- tool.WriteStep (SW,anent);
- }
-
- break;
- case 27 :
- {
- DeclareAndCast(StepAP214_AutoDesignGroupAssignment, anent, ent);
- RWStepAP214_RWAutoDesignGroupAssignment tool;
-// if (anent.IsNull()) return;
- tool.WriteStep (SW,anent);
- }
-
- break;
- case 28 :
- {
- DeclareAndCast(StepAP214_AutoDesignNominalDateAndTimeAssignment, anent, ent);
- RWStepAP214_RWAutoDesignNominalDateAndTimeAssignment tool;
-// if (anent.IsNull()) return;
- tool.WriteStep (SW,anent);
- }
-
- break;
- case 29 :
- {
- DeclareAndCast(StepAP214_AutoDesignNominalDateAssignment, anent, ent);
- RWStepAP214_RWAutoDesignNominalDateAssignment tool;
-// if (anent.IsNull()) return;
- tool.WriteStep (SW,anent);
- }
-
- break;
- case 30 :
- {
- DeclareAndCast(StepAP214_AutoDesignOrganizationAssignment, anent, ent);
- RWStepAP214_RWAutoDesignOrganizationAssignment tool;
-// if (anent.IsNull()) return;
- tool.WriteStep (SW,anent);
- }
-
+ break;
+ case 727:
+ {
+ DeclareAndCast(StepKinematics_RotationAboutDirection, anent, ent);
+ RWStepKinematics_RWRotationAboutDirection tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 728:
+ {
+ DeclareAndCast(StepKinematics_KinematicJoint, anent, ent);
+ RWStepKinematics_RWKinematicJoint tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 729:
+ {
+ DeclareAndCast(StepKinematics_ActuatedKinematicPair, anent, ent);
+ RWStepKinematics_RWActuatedKinematicPair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 730:
+ {
+ DeclareAndCast(StepKinematics_ContextDependentKinematicLinkRepresentation, anent, ent);
+ RWStepKinematics_RWContextDependentKinematicLinkRepresentation tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 731:
+ {
+ DeclareAndCast(StepKinematics_CylindricalPair, anent, ent);
+ RWStepKinematics_RWCylindricalPair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 732:
+ {
+ DeclareAndCast(StepKinematics_CylindricalPairValue, anent, ent);
+ RWStepKinematics_RWCylindricalPairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 733:
+ {
+ DeclareAndCast(StepKinematics_CylindricalPairWithRange, anent, ent);
+ RWStepKinematics_RWCylindricalPairWithRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 734:
+ {
+ DeclareAndCast(StepKinematics_FullyConstrainedPair, anent, ent);
+ RWStepKinematics_RWFullyConstrainedPair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 735:
+ {
+ DeclareAndCast(StepKinematics_GearPair, anent, ent);
+ RWStepKinematics_RWGearPair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 736:
+ {
+ DeclareAndCast(StepKinematics_GearPairValue, anent, ent);
+ RWStepKinematics_RWGearPairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 737:
+ {
+ DeclareAndCast(StepKinematics_GearPairWithRange, anent, ent);
+ RWStepKinematics_RWGearPairWithRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 738:
+ {
+ DeclareAndCast(StepKinematics_HomokineticPair, anent, ent);
+ RWStepKinematics_RWHomokineticPair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 739:
+ {
+ DeclareAndCast(StepKinematics_KinematicLink, anent, ent);
+ RWStepKinematics_RWKinematicLink tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 740:
+ {
+ DeclareAndCast(StepKinematics_KinematicLinkRepresentationAssociation, anent, ent);
+ RWStepKinematics_RWKinematicLinkRepresentationAssociation tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 741:
+ {
+ DeclareAndCast(StepKinematics_KinematicPropertyMechanismRepresentation, anent, ent);
+ RWStepKinematics_RWKinematicPropertyMechanismRepresentation tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 742:
+ {
+ DeclareAndCast(StepKinematics_KinematicTopologyStructure, anent, ent);
+ RWStepKinematics_RWKinematicTopologyStructure tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 743:
+ {
+ DeclareAndCast(StepKinematics_LowOrderKinematicPair, anent, ent);
+ RWStepKinematics_RWLowOrderKinematicPair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 744:
+ {
+ DeclareAndCast(StepKinematics_LowOrderKinematicPairValue, anent, ent);
+ RWStepKinematics_RWLowOrderKinematicPairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 745:
+ {
+ DeclareAndCast(StepKinematics_LowOrderKinematicPairWithRange, anent, ent);
+ RWStepKinematics_RWLowOrderKinematicPairWithRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 746:
+ {
+ DeclareAndCast(StepKinematics_MechanismRepresentation, anent, ent);
+ RWStepKinematics_RWMechanismRepresentation tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 747:
+ {
+ DeclareAndCast(StepKinematics_OrientedJoint, anent, ent);
+ RWStepKinematics_RWOrientedJoint tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 748:
+ {
+ DeclareAndCast(StepKinematics_PlanarCurvePair, anent, ent);
+ RWStepKinematics_RWPlanarCurvePair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 749:
+ {
+ DeclareAndCast(StepKinematics_PlanarCurvePairRange, anent, ent);
+ RWStepKinematics_RWPlanarCurvePairRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 750:
+ {
+ DeclareAndCast(StepKinematics_PlanarPair, anent, ent);
+ RWStepKinematics_RWPlanarPair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 751:
+ {
+ DeclareAndCast(StepKinematics_PlanarPairValue, anent, ent);
+ RWStepKinematics_RWPlanarPairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 752:
+ {
+ DeclareAndCast(StepKinematics_PlanarPairWithRange, anent, ent);
+ RWStepKinematics_RWPlanarPairWithRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 753:
+ {
+ DeclareAndCast(StepKinematics_PointOnPlanarCurvePair, anent, ent);
+ RWStepKinematics_RWPointOnPlanarCurvePair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 754:
+ {
+ DeclareAndCast(StepKinematics_PointOnPlanarCurvePairValue, anent, ent);
+ RWStepKinematics_RWPointOnPlanarCurvePairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 755:
+ {
+ DeclareAndCast(StepKinematics_PointOnPlanarCurvePairWithRange, anent, ent);
+ RWStepKinematics_RWPointOnPlanarCurvePairWithRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 756:
+ {
+ DeclareAndCast(StepKinematics_PointOnSurfacePair, anent, ent);
+ RWStepKinematics_RWPointOnSurfacePair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 757:
+ {
+ DeclareAndCast(StepKinematics_PointOnSurfacePairValue, anent, ent);
+ RWStepKinematics_RWPointOnSurfacePairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 758:
+ {
+ DeclareAndCast(StepKinematics_PointOnSurfacePairWithRange, anent, ent);
+ RWStepKinematics_RWPointOnSurfacePairWithRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 759:
+ {
+ DeclareAndCast(StepKinematics_PrismaticPair, anent, ent);
+ RWStepKinematics_RWPrismaticPair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 760:
+ {
+ DeclareAndCast(StepKinematics_PrismaticPairValue, anent, ent);
+ RWStepKinematics_RWPrismaticPairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 761:
+ {
+ DeclareAndCast(StepKinematics_PrismaticPairWithRange, anent, ent);
+ RWStepKinematics_RWPrismaticPairWithRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 762:
+ {
+ DeclareAndCast(StepKinematics_ProductDefinitionKinematics, anent, ent);
+ RWStepKinematics_RWProductDefinitionKinematics tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 763:
+ {
+ DeclareAndCast(StepKinematics_ProductDefinitionRelationshipKinematics, anent, ent);
+ RWStepKinematics_RWProductDefinitionRelationshipKinematics tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 764:
+ {
+ DeclareAndCast(StepKinematics_RackAndPinionPair, anent, ent);
+ RWStepKinematics_RWRackAndPinionPair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 765:
+ {
+ DeclareAndCast(StepKinematics_RackAndPinionPairValue, anent, ent);
+ RWStepKinematics_RWRackAndPinionPairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 766:
+ {
+ DeclareAndCast(StepKinematics_RackAndPinionPairWithRange, anent, ent);
+ RWStepKinematics_RWRackAndPinionPairWithRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 767:
+ {
+ DeclareAndCast(StepKinematics_RevolutePair, anent, ent);
+ RWStepKinematics_RWRevolutePair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 768:
+ {
+ DeclareAndCast(StepKinematics_RevolutePairValue, anent, ent);
+ RWStepKinematics_RWRevolutePairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 769:
+ {
+ DeclareAndCast(StepKinematics_RevolutePairWithRange, anent, ent);
+ RWStepKinematics_RWRevolutePairWithRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 770:
+ {
+ DeclareAndCast(StepKinematics_RollingCurvePair, anent, ent);
+ RWStepKinematics_RWRollingCurvePair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 771:
+ {
+ DeclareAndCast(StepKinematics_RollingCurvePairValue, anent, ent);
+ RWStepKinematics_RWRollingCurvePairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 772:
+ {
+ DeclareAndCast(StepKinematics_RollingSurfacePair, anent, ent);
+ RWStepKinematics_RWRollingSurfacePair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 773:
+ {
+ DeclareAndCast(StepKinematics_RollingSurfacePairValue, anent, ent);
+ RWStepKinematics_RWRollingSurfacePairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 774:
+ {
+ DeclareAndCast(StepKinematics_ScrewPair, anent, ent);
+ RWStepKinematics_RWScrewPair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 775:
+ {
+ DeclareAndCast(StepKinematics_ScrewPairValue, anent, ent);
+ RWStepKinematics_RWScrewPairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 776:
+ {
+ DeclareAndCast(StepKinematics_ScrewPairWithRange, anent, ent);
+ RWStepKinematics_RWScrewPairWithRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 777:
+ {
+ DeclareAndCast(StepKinematics_SlidingCurvePair, anent, ent);
+ RWStepKinematics_RWSlidingCurvePair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 778:
+ {
+ DeclareAndCast(StepKinematics_SlidingCurvePairValue, anent, ent);
+ RWStepKinematics_RWSlidingCurvePairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 779:
+ {
+ DeclareAndCast(StepKinematics_SlidingSurfacePair, anent, ent);
+ RWStepKinematics_RWSlidingSurfacePair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 780:
+ {
+ DeclareAndCast(StepKinematics_SlidingSurfacePairValue, anent, ent);
+ RWStepKinematics_RWSlidingSurfacePairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 781:
+ {
+ DeclareAndCast(StepKinematics_SphericalPair, anent, ent);
+ RWStepKinematics_RWSphericalPair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 782:
+ {
+ DeclareAndCast(StepKinematics_SphericalPairValue, anent, ent);
+ RWStepKinematics_RWSphericalPairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 783:
+ {
+ DeclareAndCast(StepKinematics_SphericalPairWithPin, anent, ent);
+ RWStepKinematics_RWSphericalPairWithPin tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 784:
+ {
+ DeclareAndCast(StepKinematics_SphericalPairWithPinAndRange, anent, ent);
+ RWStepKinematics_RWSphericalPairWithPinAndRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 785:
+ {
+ DeclareAndCast(StepKinematics_SphericalPairWithRange, anent, ent);
+ RWStepKinematics_RWSphericalPairWithRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 786:
+ {
+ DeclareAndCast(StepKinematics_SurfacePairWithRange, anent, ent);
+ RWStepKinematics_RWSurfacePairWithRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 787:
+ {
+ DeclareAndCast(StepKinematics_UnconstrainedPair, anent, ent);
+ RWStepKinematics_RWUnconstrainedPair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 788:
+ {
+ DeclareAndCast(StepKinematics_UnconstrainedPairValue, anent, ent);
+ RWStepKinematics_RWUnconstrainedPairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 789:
+ {
+ DeclareAndCast(StepKinematics_UniversalPair, anent, ent);
+ RWStepKinematics_RWUniversalPair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 790:
+ {
+ DeclareAndCast(StepKinematics_UniversalPairValue, anent, ent);
+ RWStepKinematics_RWUniversalPairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 791:
+ {
+ DeclareAndCast(StepKinematics_UniversalPairWithRange, anent, ent);
+ RWStepKinematics_RWUniversalPairWithRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 792:
+ {
+ DeclareAndCast(StepKinematics_PairRepresentationRelationship, anent, ent);
+ RWStepKinematics_RWPairRepresentationRelationship tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 793:
+ {
+ DeclareAndCast(StepKinematics_RigidLinkRepresentation, anent, ent);
+ RWStepKinematics_RWRigidLinkRepresentation tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 794:
+ {
+ DeclareAndCast(StepKinematics_KinematicTopologyDirectedStructure, anent, ent);
+ RWStepKinematics_RWKinematicTopologyDirectedStructure tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 795:
+ {
+ DeclareAndCast(StepKinematics_KinematicTopologyNetworkStructure, anent, ent);
+ RWStepKinematics_RWKinematicTopologyNetworkStructure tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 796:
+ {
+ DeclareAndCast(StepKinematics_LinearFlexibleAndPinionPair, anent, ent);
+ RWStepKinematics_RWLinearFlexibleAndPinionPair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 797:
+ {
+ DeclareAndCast(StepKinematics_LinearFlexibleAndPlanarCurvePair, anent, ent);
+ RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 798:
+ {
+ DeclareAndCast(StepKinematics_LinearFlexibleLinkRepresentation, anent, ent);
+ RWStepKinematics_RWLinearFlexibleLinkRepresentation tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 800:
+ {
+ DeclareAndCast(StepKinematics_ActuatedKinPairAndOrderKinPair, anent, ent);
+ RWStepKinematics_RWActuatedKinPairAndOrderKinPair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 801:
+ {
+ DeclareAndCast(StepKinematics_MechanismStateRepresentation, anent, ent);
+ RWStepKinematics_RWMechanismStateRepresentation tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+
+ default:
+ ach->AddFail("Type Mismatch when reading - Entity");
+ }
+ return;
+}
+
+
+//=======================================================================
+//function : WriteStep
+//purpose : Writing of a file
+//=======================================================================
+
+void RWStepAP214_ReadWriteModule::WriteStep(const Standard_Integer CN,
+ StepData_StepWriter& SW,
+ const Handle(Standard_Transient)&ent) const
+{
+ if (CN == 0) return;
+ switch (CN) {
+ case 1 :
+ {
+ DeclareAndCast(StepBasic_Address, anent, ent);
+ RWStepBasic_RWAddress tool;
+// if (anent.IsNull()) return;
+ tool.WriteStep (SW,anent);
+ }
+
+ break;
+ case 2 :
+ {
+ DeclareAndCast(StepShape_AdvancedBrepShapeRepresentation, anent, ent);
+ RWStepShape_RWAdvancedBrepShapeRepresentation tool;
+// if (anent.IsNull()) return;
+ tool.WriteStep (SW,anent);
+ }
+
+ break;
+ case 3 :
+ {
+ DeclareAndCast(StepShape_AdvancedFace, anent, ent);
+ RWStepShape_RWAdvancedFace tool;
+// if (anent.IsNull()) return;
+ tool.WriteStep (SW,anent);
+ }
+
+ break;
+ case 4 :
+ {
+ DeclareAndCast(StepVisual_AnnotationCurveOccurrence, anent, ent);
+ RWStepVisual_RWAnnotationCurveOccurrence tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 5:
+ {
+ DeclareAndCast(StepVisual_AnnotationFillArea, anent, ent);
+ RWStepVisual_RWAnnotationFillArea tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 6:
+ {
+ DeclareAndCast(StepVisual_AnnotationFillAreaOccurrence, anent, ent);
+ RWStepVisual_RWAnnotationFillAreaOccurrence tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 7 :
+ {
+ DeclareAndCast(StepVisual_AnnotationOccurrence, anent, ent);
+ RWStepVisual_RWAnnotationOccurrence tool;
+ tool.WriteStep (SW,anent);
+ }
+
+ break;
+ case 11 :
+ {
+ DeclareAndCast(StepRepr_MappedItem, anent, ent);
+ RWStepRepr_RWMappedItem tool;
+// if (anent.IsNull()) return;
+ tool.WriteStep (SW,anent);
+ }
+
+ break;
+ case 12 :
+ {
+ DeclareAndCast(StepVisual_StyledItem, anent, ent);
+ RWStepVisual_RWStyledItem tool;
+// if (anent.IsNull()) return;
+ tool.WriteStep (SW,anent);
+ }
+
+ break;
+ case 13 :
+ {
+ DeclareAndCast(StepBasic_ApplicationContext, anent, ent);
+ RWStepBasic_RWApplicationContext tool;
+// if (anent.IsNull()) return;
+ tool.WriteStep (SW,anent);
+ }
+
+ break;
+ case 14 :
+ {
+ DeclareAndCast(StepBasic_ApplicationContextElement, anent, ent);
+ RWStepBasic_RWApplicationContextElement tool;
+// if (anent.IsNull()) return;
+ tool.WriteStep (SW,anent);
+ }
+
+ break;
+ case 15 :
+ {
+ DeclareAndCast(StepBasic_ApplicationProtocolDefinition, anent, ent);
+ RWStepBasic_RWApplicationProtocolDefinition tool;
+// if (anent.IsNull()) return;
+ tool.WriteStep (SW,anent);
+ }
+
+ break;
+ case 16 :
+ {
+ DeclareAndCast(StepBasic_Approval, anent, ent);
+ RWStepBasic_RWApproval tool;
+// if (anent.IsNull()) return;
+ tool.WriteStep (SW,anent);
+ }
+
+ break;
+ case 18 :
+ {
+ DeclareAndCast(StepBasic_ApprovalPersonOrganization, anent, ent);
+ RWStepBasic_RWApprovalPersonOrganization tool;
+// if (anent.IsNull()) return;
+ tool.WriteStep (SW,anent);
+ }
+
+ break;
+ case 19 :
+ {
+ DeclareAndCast(StepBasic_ApprovalRelationship, anent, ent);
+ RWStepBasic_RWApprovalRelationship tool;
+// if (anent.IsNull()) return;
+ tool.WriteStep (SW,anent);
+ }
+
+ break;
+ case 20 :
+ {
+ DeclareAndCast(StepBasic_ApprovalRole, anent, ent);
+ RWStepBasic_RWApprovalRole tool;
+// if (anent.IsNull()) return;
+ tool.WriteStep (SW,anent);
+ }
+
+ break;
+ case 21 :
+ {
+ DeclareAndCast(StepBasic_ApprovalStatus, anent, ent);
+ RWStepBasic_RWApprovalStatus tool;
+// if (anent.IsNull()) return;
+ tool.WriteStep (SW,anent);
+ }
+
+ break;
+ case 22 :
+ {
+ DeclareAndCast(StepVisual_AreaInSet, anent, ent);
+ RWStepVisual_RWAreaInSet tool;
+// if (anent.IsNull()) return;
+ tool.WriteStep (SW,anent);
+ }
+
+ break;
+ case 23 :
+ {
+ DeclareAndCast(StepAP214_AutoDesignActualDateAndTimeAssignment, anent, ent);
+ RWStepAP214_RWAutoDesignActualDateAndTimeAssignment tool;
+// if (anent.IsNull()) return;
+ tool.WriteStep (SW,anent);
+ }
+
+ break;
+ case 24 :
+ {
+ DeclareAndCast(StepAP214_AutoDesignActualDateAssignment, anent, ent);
+ RWStepAP214_RWAutoDesignActualDateAssignment tool;
+// if (anent.IsNull()) return;
+ tool.WriteStep (SW,anent);
+ }
+
+ break;
+ case 25 :
+ {
+ DeclareAndCast(StepAP214_AutoDesignApprovalAssignment, anent, ent);
+ RWStepAP214_RWAutoDesignApprovalAssignment tool;
+// if (anent.IsNull()) return;
+ tool.WriteStep (SW,anent);
+ }
+
+ break;
+ case 26 :
+ {
+ DeclareAndCast(StepAP214_AutoDesignDateAndPersonAssignment, anent, ent);
+ RWStepAP214_RWAutoDesignDateAndPersonAssignment tool;
+// if (anent.IsNull()) return;
+ tool.WriteStep (SW,anent);
+ }
+
+ break;
+ case 27 :
+ {
+ DeclareAndCast(StepAP214_AutoDesignGroupAssignment, anent, ent);
+ RWStepAP214_RWAutoDesignGroupAssignment tool;
+// if (anent.IsNull()) return;
+ tool.WriteStep (SW,anent);
+ }
+
+ break;
+ case 28 :
+ {
+ DeclareAndCast(StepAP214_AutoDesignNominalDateAndTimeAssignment, anent, ent);
+ RWStepAP214_RWAutoDesignNominalDateAndTimeAssignment tool;
+// if (anent.IsNull()) return;
+ tool.WriteStep (SW,anent);
+ }
+
+ break;
+ case 29 :
+ {
+ DeclareAndCast(StepAP214_AutoDesignNominalDateAssignment, anent, ent);
+ RWStepAP214_RWAutoDesignNominalDateAssignment tool;
+// if (anent.IsNull()) return;
+ tool.WriteStep (SW,anent);
+ }
+
+ break;
+ case 30 :
+ {
+ DeclareAndCast(StepAP214_AutoDesignOrganizationAssignment, anent, ent);
+ RWStepAP214_RWAutoDesignOrganizationAssignment tool;
+// if (anent.IsNull()) return;
+ tool.WriteStep (SW,anent);
+ }
+
break;
case 31 :
{
tool.WriteStep (SW,anent);
}
break;
- case 697:
+ case 697:
+ {
+ DeclareAndCast(StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol,anent,ent);
+ RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndUneqDisGeoTol tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 698:
+ {
+ DeclareAndCast(StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp,anent,ent);
+ RWStepRepr_RWCompGroupShAspAndCompShAspAndDatumFeatAndShAsp tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 699:
+ {
+ DeclareAndCast(StepRepr_CompShAspAndDatumFeatAndShAsp,anent,ent);
+ RWStepRepr_RWCompShAspAndDatumFeatAndShAsp tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 700:
+ {
+ DeclareAndCast(StepRepr_IntegerRepresentationItem,anent,ent);
+ RWStepRepr_RWIntegerRepresentationItem tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 701:
+ {
+ DeclareAndCast(StepRepr_ValueRepresentationItem,anent,ent);
+ RWStepRepr_RWValueRepresentationItem tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 702:
+ {
+ DeclareAndCast(StepRepr_FeatureForDatumTargetRelationship,anent,ent);
+ RWStepRepr_RWFeatureForDatumTargetRelationship tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 703:
+ {
+ DeclareAndCast(StepAP242_DraughtingModelItemAssociation,anent,ent);
+ RWStepAP242_RWDraughtingModelItemAssociation tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 704:
+ {
+ DeclareAndCast(StepVisual_AnnotationPlane,anent,ent);
+ RWStepVisual_RWAnnotationPlane tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 705:
+ {
+ DeclareAndCast(StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMaxTol,anent,ent);
+ RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMaxTol tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 706:
+ {
+ DeclareAndCast(StepDimTol_GeoTolAndGeoTolWthMaxTol,anent,ent);
+ RWStepDimTol_RWGeoTolAndGeoTolWthMaxTol tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 707:
+ {
+ DeclareAndCast(StepVisual_TessellatedAnnotationOccurrence,anent,ent);
+ RWStepVisual_RWTessellatedAnnotationOccurrence tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+
+ case 708:
+ {
+ DeclareAndCast(StepVisual_TessellatedItem,anent,ent);
+ RWStepVisual_RWTessellatedItem tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+
+ case 709:
+ {
+ DeclareAndCast(StepVisual_TessellatedGeometricSet,anent,ent);
+ RWStepVisual_RWTessellatedGeometricSet tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 710:
+ {
+ DeclareAndCast(StepVisual_TessellatedCurveSet,anent,ent);
+ RWStepVisual_RWTessellatedCurveSet tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 711:
+ {
+ DeclareAndCast(StepVisual_CoordinatesList,anent,ent);
+ RWStepVisual_RWCoordinatesList tool;
+ tool.WriteStep(SW,anent);
+ }
+ break;
+ case 712:
{
- DeclareAndCast(StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol,anent,ent);
- RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndUneqDisGeoTol tool;
- tool.WriteStep (SW,anent);
+ DeclareAndCast(StepRepr_ConstructiveGeometryRepresentation,anent,ent);
+ RWStepRepr_RWConstructiveGeometryRepresentation tool;
+ tool.WriteStep(SW,anent);
}
break;
- case 698:
+ case 713:
{
- DeclareAndCast(StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp,anent,ent);
- RWStepRepr_RWCompGroupShAspAndCompShAspAndDatumFeatAndShAsp tool;
- tool.WriteStep (SW,anent);
+ DeclareAndCast(StepRepr_ConstructiveGeometryRepresentationRelationship,anent,ent);
+ RWStepRepr_RWConstructiveGeometryRepresentationRelationship tool;
+ tool.WriteStep(SW,anent);
}
break;
- case 699:
+ case 714:
{
- DeclareAndCast(StepRepr_CompShAspAndDatumFeatAndShAsp,anent,ent);
- RWStepRepr_RWCompShAspAndDatumFeatAndShAsp tool;
- tool.WriteStep (SW,anent);
+ DeclareAndCast(StepRepr_CharacterizedRepresentation, anent, ent);
+ RWStepRepr_RWCharacterizedRepresentation tool;
+ tool.WriteStep(SW, anent);
}
break;
- case 700:
+ case 715:
{
- DeclareAndCast(StepRepr_IntegerRepresentationItem,anent,ent);
- RWStepRepr_RWIntegerRepresentationItem tool;
- tool.WriteStep (SW,anent);
+ DeclareAndCast(StepVisual_CharacterizedObjAndRepresentationAndDraughtingModel, anent, ent);
+ RWStepVisual_RWCharacterizedObjAndRepresentationAndDraughtingModel tool;
+ tool.WriteStep(SW, anent);
}
break;
- case 701:
+ case 716:
{
- DeclareAndCast(StepRepr_ValueRepresentationItem,anent,ent);
- RWStepRepr_RWValueRepresentationItem tool;
- tool.WriteStep (SW,anent);
+ DeclareAndCast(StepVisual_CameraModelD3MultiClipping, anent, ent);
+ RWStepVisual_RWCameraModelD3MultiClipping tool;
+ tool.WriteStep(SW, anent);
}
break;
- case 702:
+ case 717:
{
- DeclareAndCast(StepRepr_FeatureForDatumTargetRelationship,anent,ent);
- RWStepRepr_RWFeatureForDatumTargetRelationship tool;
- tool.WriteStep (SW,anent);
+ DeclareAndCast(StepVisual_CameraModelD3MultiClippingIntersection, anent, ent);
+ RWStepVisual_RWCameraModelD3MultiClippingIntersection tool;
+ tool.WriteStep(SW, anent);
}
break;
- case 703:
+ case 718:
{
- DeclareAndCast(StepAP242_DraughtingModelItemAssociation,anent,ent);
- RWStepAP242_RWDraughtingModelItemAssociation tool;
- tool.WriteStep (SW,anent);
+ DeclareAndCast(StepVisual_CameraModelD3MultiClippingUnion, anent, ent);
+ RWStepVisual_RWCameraModelD3MultiClippingUnion tool;
+ tool.WriteStep(SW, anent);
}
break;
- case 704:
+ case 719:
{
- DeclareAndCast(StepVisual_AnnotationPlane,anent,ent);
- RWStepVisual_RWAnnotationPlane tool;
- tool.WriteStep (SW,anent);
+ DeclareAndCast(StepVisual_AnnotationCurveOccurrenceAndGeomReprItem, anent, ent);
+ RWStepVisual_RWAnnotationCurveOccurrenceAndGeomReprItem tool;
+ tool.WriteStep(SW, anent);
}
- break;
- case 705:
+ break;
+ case 720:
{
- DeclareAndCast(StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMaxTol,anent,ent);
- RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMaxTol tool;
- tool.WriteStep (SW,anent);
+ DeclareAndCast(StepVisual_SurfaceStyleTransparent, anent, ent);
+ RWStepVisual_RWSurfaceStyleTransparent tool;
+ tool.WriteStep(SW, anent);
}
break;
- case 706:
+ case 721:
{
- DeclareAndCast(StepDimTol_GeoTolAndGeoTolWthMaxTol,anent,ent);
- RWStepDimTol_RWGeoTolAndGeoTolWthMaxTol tool;
- tool.WriteStep (SW,anent);
+ DeclareAndCast(StepVisual_SurfaceStyleReflectanceAmbient, anent, ent);
+ RWStepVisual_RWSurfaceStyleReflectanceAmbient tool;
+ tool.WriteStep(SW, anent);
}
break;
- case 707:
+ case 722:
{
- DeclareAndCast(StepVisual_TessellatedAnnotationOccurrence,anent,ent);
- RWStepVisual_RWTessellatedAnnotationOccurrence tool;
- tool.WriteStep (SW,anent);
+ DeclareAndCast(StepVisual_SurfaceStyleRendering, anent, ent);
+ RWStepVisual_RWSurfaceStyleRendering tool;
+ tool.WriteStep(SW, anent);
}
break;
-
- case 708:
+ case 723:
{
- DeclareAndCast(StepVisual_TessellatedItem,anent,ent);
- RWStepVisual_RWTessellatedItem tool;
- tool.WriteStep (SW,anent);
+ DeclareAndCast(StepVisual_SurfaceStyleRenderingWithProperties, anent, ent);
+ RWStepVisual_RWSurfaceStyleRenderingWithProperties tool;
+ tool.WriteStep(SW, anent);
}
break;
+ case 724:
+ {
+ DeclareAndCast(StepRepr_RepresentationContextReference, anent, ent);
+ RWStepRepr_RWRepresentationContextReference tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 725:
+ {
+ DeclareAndCast(StepRepr_RepresentationReference, anent, ent);
+ RWStepRepr_RWRepresentationReference tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 726:
+ {
+ DeclareAndCast(StepGeom_SuParameters, anent, ent);
+ RWStepGeom_RWSuParameters tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 727:
+ {
+ DeclareAndCast(StepKinematics_RotationAboutDirection, anent, ent);
+ RWStepKinematics_RWRotationAboutDirection tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 728:
+ {
+ DeclareAndCast(StepKinematics_KinematicJoint, anent, ent);
+ RWStepKinematics_RWKinematicJoint tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 729:
+ {
+ DeclareAndCast(StepKinematics_ActuatedKinematicPair, anent, ent);
+ RWStepKinematics_RWActuatedKinematicPair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 730:
+ {
+ DeclareAndCast(StepKinematics_ContextDependentKinematicLinkRepresentation, anent, ent);
+ RWStepKinematics_RWContextDependentKinematicLinkRepresentation tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 731:
+ {
+ DeclareAndCast(StepKinematics_CylindricalPair, anent, ent);
+ RWStepKinematics_RWCylindricalPair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 732:
+ {
+ DeclareAndCast(StepKinematics_CylindricalPairValue, anent, ent);
+ RWStepKinematics_RWCylindricalPairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 733:
+ {
+ DeclareAndCast(StepKinematics_CylindricalPairWithRange, anent, ent);
+ RWStepKinematics_RWCylindricalPairWithRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 734:
+ {
+ DeclareAndCast(StepKinematics_FullyConstrainedPair, anent, ent);
+ RWStepKinematics_RWFullyConstrainedPair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 735:
+ {
+ DeclareAndCast(StepKinematics_GearPair, anent, ent);
+ RWStepKinematics_RWGearPair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 736:
+ {
+ DeclareAndCast(StepKinematics_GearPairValue, anent, ent);
+ RWStepKinematics_RWGearPairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 737:
+ {
+ DeclareAndCast(StepKinematics_GearPairWithRange, anent, ent);
+ RWStepKinematics_RWGearPairWithRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 738:
+ {
+ DeclareAndCast(StepKinematics_HomokineticPair, anent, ent);
+ RWStepKinematics_RWHomokineticPair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 739:
+ {
+ DeclareAndCast(StepKinematics_KinematicLink, anent, ent);
+ RWStepKinematics_RWKinematicLink tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 740:
+ {
+ DeclareAndCast(StepKinematics_KinematicLinkRepresentationAssociation, anent, ent);
+ RWStepKinematics_RWKinematicLinkRepresentationAssociation tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 741:
+ {
+ DeclareAndCast(StepKinematics_KinematicPropertyMechanismRepresentation, anent, ent);
+ RWStepKinematics_RWKinematicPropertyMechanismRepresentation tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 742:
+ {
+ DeclareAndCast(StepKinematics_KinematicTopologyStructure, anent, ent);
+ RWStepKinematics_RWKinematicTopologyStructure tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 743:
+ {
+ DeclareAndCast(StepKinematics_LowOrderKinematicPair, anent, ent);
+ RWStepKinematics_RWLowOrderKinematicPair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 744:
+ {
+ DeclareAndCast(StepKinematics_LowOrderKinematicPairValue, anent, ent);
+ RWStepKinematics_RWLowOrderKinematicPairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 745:
+ {
+ DeclareAndCast(StepKinematics_LowOrderKinematicPairWithRange, anent, ent);
+ RWStepKinematics_RWLowOrderKinematicPairWithRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 746:
+ {
+ DeclareAndCast(StepKinematics_MechanismRepresentation, anent, ent);
+ RWStepKinematics_RWMechanismRepresentation tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 747:
+ {
+ DeclareAndCast(StepKinematics_OrientedJoint, anent, ent);
+ RWStepKinematics_RWOrientedJoint tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 748:
+ {
+ DeclareAndCast(StepKinematics_PlanarCurvePair, anent, ent);
+ RWStepKinematics_RWPlanarCurvePair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 749:
+ {
+ DeclareAndCast(StepKinematics_PlanarCurvePairRange, anent, ent);
+ RWStepKinematics_RWPlanarCurvePairRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 750:
+ {
+ DeclareAndCast(StepKinematics_PlanarPair, anent, ent);
+ RWStepKinematics_RWPlanarPair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 751:
+ {
+ DeclareAndCast(StepKinematics_PlanarPairValue, anent, ent);
+ RWStepKinematics_RWPlanarPairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 752:
+ {
+ DeclareAndCast(StepKinematics_PlanarPairWithRange, anent, ent);
+ RWStepKinematics_RWPlanarPairWithRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 753:
+ {
+ DeclareAndCast(StepKinematics_PointOnPlanarCurvePair, anent, ent);
+ RWStepKinematics_RWPointOnPlanarCurvePair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 754:
+ {
+ DeclareAndCast(StepKinematics_PointOnPlanarCurvePairValue, anent, ent);
+ RWStepKinematics_RWPointOnPlanarCurvePairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 755:
+ {
+ DeclareAndCast(StepKinematics_PointOnPlanarCurvePairWithRange, anent, ent);
+ RWStepKinematics_RWPointOnPlanarCurvePairWithRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 756:
+ {
+ DeclareAndCast(StepKinematics_PointOnSurfacePair, anent, ent);
+ RWStepKinematics_RWPointOnSurfacePair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 757:
+ {
+ DeclareAndCast(StepKinematics_PointOnSurfacePairValue, anent, ent);
+ RWStepKinematics_RWPointOnSurfacePairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 758:
+ {
+ DeclareAndCast(StepKinematics_PointOnSurfacePairWithRange, anent, ent);
+ RWStepKinematics_RWPointOnSurfacePairWithRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 759:
+ {
+ DeclareAndCast(StepKinematics_PrismaticPair, anent, ent);
+ RWStepKinematics_RWPrismaticPair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 760:
+ {
+ DeclareAndCast(StepKinematics_PrismaticPairValue, anent, ent);
+ RWStepKinematics_RWPrismaticPairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 761:
+ {
+ DeclareAndCast(StepKinematics_PrismaticPairWithRange, anent, ent);
+ RWStepKinematics_RWPrismaticPairWithRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 762:
+ {
+ DeclareAndCast(StepKinematics_ProductDefinitionKinematics, anent, ent);
+ RWStepKinematics_RWProductDefinitionKinematics tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 763:
+ {
+ DeclareAndCast(StepKinematics_ProductDefinitionRelationshipKinematics, anent, ent);
+ RWStepKinematics_RWProductDefinitionRelationshipKinematics tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 764:
+ {
+ DeclareAndCast(StepKinematics_RackAndPinionPair, anent, ent);
+ RWStepKinematics_RWRackAndPinionPair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 765:
+ {
+ DeclareAndCast(StepKinematics_RackAndPinionPairValue, anent, ent);
+ RWStepKinematics_RWRackAndPinionPairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 766:
+ {
+ DeclareAndCast(StepKinematics_RackAndPinionPairWithRange, anent, ent);
+ RWStepKinematics_RWRackAndPinionPairWithRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 767:
+ {
+ DeclareAndCast(StepKinematics_RevolutePair, anent, ent);
+ RWStepKinematics_RWRevolutePair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 768:
+ {
+ DeclareAndCast(StepKinematics_RevolutePairValue, anent, ent);
+ RWStepKinematics_RWRevolutePairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 769:
+ {
+ DeclareAndCast(StepKinematics_RevolutePairWithRange, anent, ent);
+ RWStepKinematics_RWRevolutePairWithRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 770:
+ {
+ DeclareAndCast(StepKinematics_RollingCurvePair, anent, ent);
+ RWStepKinematics_RWRollingCurvePair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 771:
+ {
+ DeclareAndCast(StepKinematics_RollingCurvePairValue, anent, ent);
+ RWStepKinematics_RWRollingCurvePairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 772:
+ {
+ DeclareAndCast(StepKinematics_RollingSurfacePair, anent, ent);
+ RWStepKinematics_RWRollingSurfacePair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 773:
+ {
+ DeclareAndCast(StepKinematics_RollingSurfacePairValue, anent, ent);
+ RWStepKinematics_RWRollingSurfacePairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 774:
+ {
+ DeclareAndCast(StepKinematics_ScrewPair, anent, ent);
+ RWStepKinematics_RWScrewPair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 775:
+ {
+ DeclareAndCast(StepKinematics_ScrewPairValue, anent, ent);
+ RWStepKinematics_RWScrewPairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 776:
+ {
+ DeclareAndCast(StepKinematics_ScrewPairWithRange, anent, ent);
+ RWStepKinematics_RWScrewPairWithRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 777:
+ {
+ DeclareAndCast(StepKinematics_SlidingCurvePair, anent, ent);
+ RWStepKinematics_RWSlidingCurvePair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 778:
+ {
+ DeclareAndCast(StepKinematics_SlidingCurvePairValue, anent, ent);
+ RWStepKinematics_RWSlidingCurvePairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 779:
+ {
+ DeclareAndCast(StepKinematics_SlidingSurfacePair, anent, ent);
+ RWStepKinematics_RWSlidingSurfacePair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 780:
+ {
+ DeclareAndCast(StepKinematics_SlidingSurfacePairValue, anent, ent);
+ RWStepKinematics_RWSlidingSurfacePairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 781:
+ {
+ DeclareAndCast(StepKinematics_SphericalPair, anent, ent);
+ RWStepKinematics_RWSphericalPair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 782:
+ {
+ DeclareAndCast(StepKinematics_SphericalPairValue, anent, ent);
+ RWStepKinematics_RWSphericalPairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 783:
+ {
+ DeclareAndCast(StepKinematics_SphericalPairWithPin, anent, ent);
+ RWStepKinematics_RWSphericalPairWithPin tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 784:
+ {
+ DeclareAndCast(StepKinematics_SphericalPairWithPinAndRange, anent, ent);
+ RWStepKinematics_RWSphericalPairWithPinAndRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 785:
+ {
+ DeclareAndCast(StepKinematics_SphericalPairWithRange, anent, ent);
+ RWStepKinematics_RWSphericalPairWithRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 786:
+ {
+ DeclareAndCast(StepKinematics_SurfacePairWithRange, anent, ent);
+ RWStepKinematics_RWSurfacePairWithRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 787:
+ {
+ DeclareAndCast(StepKinematics_UnconstrainedPair, anent, ent);
+ RWStepKinematics_RWUnconstrainedPair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 788:
+ {
+ DeclareAndCast(StepKinematics_UnconstrainedPairValue, anent, ent);
+ RWStepKinematics_RWUnconstrainedPairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 789:
+ {
+ DeclareAndCast(StepKinematics_UniversalPair, anent, ent);
+ RWStepKinematics_RWUniversalPair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 790:
+ {
+ DeclareAndCast(StepKinematics_UniversalPairValue, anent, ent);
+ RWStepKinematics_RWUniversalPairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 791:
+ {
+ DeclareAndCast(StepKinematics_UniversalPairWithRange, anent, ent);
+ RWStepKinematics_RWUniversalPairWithRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 792:
+ {
+ DeclareAndCast(StepKinematics_PairRepresentationRelationship, anent, ent);
+ RWStepKinematics_RWPairRepresentationRelationship tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 793:
+ {
+ DeclareAndCast(StepKinematics_RigidLinkRepresentation, anent, ent);
+ RWStepKinematics_RWRigidLinkRepresentation tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 794:
+ {
+ DeclareAndCast(StepKinematics_KinematicTopologyDirectedStructure, anent, ent);
+ RWStepKinematics_RWKinematicTopologyDirectedStructure tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 795:
+ {
+ DeclareAndCast(StepKinematics_KinematicTopologyNetworkStructure, anent, ent);
+ RWStepKinematics_RWKinematicTopologyNetworkStructure tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 796:
+ {
+ DeclareAndCast(StepKinematics_LinearFlexibleAndPinionPair, anent, ent);
+ RWStepKinematics_RWLinearFlexibleAndPinionPair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 797:
+ {
+ DeclareAndCast(StepKinematics_LinearFlexibleAndPlanarCurvePair, anent, ent);
+ RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 798:
+ {
+ DeclareAndCast(StepKinematics_LinearFlexibleLinkRepresentation, anent, ent);
+ RWStepKinematics_RWLinearFlexibleLinkRepresentation tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 800:
+ {
+ DeclareAndCast(StepKinematics_ActuatedKinPairAndOrderKinPair, anent, ent);
+ RWStepKinematics_RWActuatedKinPairAndOrderKinPair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 801:
+ {
+ DeclareAndCast(StepKinematics_MechanismStateRepresentation, anent, ent);
+ RWStepKinematics_RWMechanismStateRepresentation tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
- case 709:
- {
- DeclareAndCast(StepVisual_TessellatedGeometricSet,anent,ent);
- RWStepVisual_RWTessellatedGeometricSet tool;
- tool.WriteStep (SW,anent);
- }
- break;
- case 710:
- {
- DeclareAndCast(StepVisual_TessellatedCurveSet,anent,ent);
- RWStepVisual_RWTessellatedCurveSet tool;
- tool.WriteStep (SW,anent);
- }
- break;
- case 711:
- {
- DeclareAndCast(StepVisual_CoordinatesList,anent,ent);
- RWStepVisual_RWCoordinatesList tool;
- tool.WriteStep(SW,anent);
- }
- break;
- case 712:
- {
- DeclareAndCast(StepRepr_ConstructiveGeometryRepresentation,anent,ent);
- RWStepRepr_RWConstructiveGeometryRepresentation tool;
- tool.WriteStep(SW,anent);
- }
- break;
- case 713:
- {
- DeclareAndCast(StepRepr_ConstructiveGeometryRepresentationRelationship,anent,ent);
- RWStepRepr_RWConstructiveGeometryRepresentationRelationship tool;
- tool.WriteStep(SW,anent);
- }
- break;
- case 714:
- {
- DeclareAndCast(StepRepr_CharacterizedRepresentation, anent, ent);
- RWStepRepr_RWCharacterizedRepresentation tool;
- tool.WriteStep(SW, anent);
- }
- break;
- case 715:
- {
- DeclareAndCast(StepVisual_CharacterizedObjAndRepresentationAndDraughtingModel, anent, ent);
- RWStepVisual_RWCharacterizedObjAndRepresentationAndDraughtingModel tool;
- tool.WriteStep(SW, anent);
- }
- break;
- case 716:
- {
- DeclareAndCast(StepVisual_CameraModelD3MultiClipping, anent, ent);
- RWStepVisual_RWCameraModelD3MultiClipping tool;
- tool.WriteStep(SW, anent);
- }
- break;
- case 717:
- {
- DeclareAndCast(StepVisual_CameraModelD3MultiClippingIntersection, anent, ent);
- RWStepVisual_RWCameraModelD3MultiClippingIntersection tool;
- tool.WriteStep(SW, anent);
- }
- break;
- case 718:
- {
- DeclareAndCast(StepVisual_CameraModelD3MultiClippingUnion, anent, ent);
- RWStepVisual_RWCameraModelD3MultiClippingUnion tool;
- tool.WriteStep(SW, anent);
- }
- break;
- case 719:
- {
- DeclareAndCast(StepVisual_AnnotationCurveOccurrenceAndGeomReprItem, anent, ent);
- RWStepVisual_RWAnnotationCurveOccurrenceAndGeomReprItem tool;
- tool.WriteStep(SW, anent);
- }
- break;
- case 720:
- {
- DeclareAndCast(StepVisual_SurfaceStyleTransparent, anent, ent);
- RWStepVisual_RWSurfaceStyleTransparent tool;
- tool.WriteStep(SW, anent);
- }
- break;
- case 721:
- {
- DeclareAndCast(StepVisual_SurfaceStyleReflectanceAmbient, anent, ent);
- RWStepVisual_RWSurfaceStyleReflectanceAmbient tool;
- tool.WriteStep(SW, anent);
- }
- break;
- case 722:
- {
- DeclareAndCast(StepVisual_SurfaceStyleRendering, anent, ent);
- RWStepVisual_RWSurfaceStyleRendering tool;
- tool.WriteStep(SW, anent);
- }
- break;
- case 723:
- {
- DeclareAndCast(StepVisual_SurfaceStyleRenderingWithProperties, anent, ent);
- RWStepVisual_RWSurfaceStyleRenderingWithProperties tool;
- tool.WriteStep(SW, anent);
- }
- break;
default:
return;
}
RWStepGeom_RWSeamCurve.hxx
RWStepGeom_RWSphericalSurface.cxx
RWStepGeom_RWSphericalSurface.hxx
+RWStepGeom_RWSuParameters.cxx
+RWStepGeom_RWSuParameters.hxx
RWStepGeom_RWSurface.cxx
RWStepGeom_RWSurface.hxx
RWStepGeom_RWSurfaceCurve.cxx
--- /dev/null
+// Created on : Sat May 02 12:41:14 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepGeom_RWSuParameters.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepGeom_SuParameters.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepGeom_RWSuParameters
+//purpose :
+//=======================================================================
+
+RWStepGeom_RWSuParameters::RWStepGeom_RWSuParameters() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepGeom_RWSuParameters::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theAch,
+ const Handle(StepGeom_SuParameters)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,7,theAch,"su_parameters") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theAch, aRepresentationItem_Name);
+
+ // Own fields of SuParameters
+
+ Standard_Real aA;
+ theData->ReadReal (theNum, 2, "a", theAch, aA);
+
+ Standard_Real aAlpha;
+ theData->ReadReal (theNum, 3, "alpha", theAch, aAlpha);
+
+ Standard_Real aB;
+ theData->ReadReal (theNum, 4, "b", theAch, aB);
+
+ Standard_Real aBeta;
+ theData->ReadReal (theNum, 5, "beta", theAch, aBeta);
+
+ Standard_Real aC;
+ theData->ReadReal (theNum, 6, "c", theAch, aC);
+
+ Standard_Real aGamma;
+ theData->ReadReal (theNum, 7, "gamma", theAch, aGamma);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aA,
+ aAlpha,
+ aB,
+ aBeta,
+ aC,
+ aGamma);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepGeom_RWSuParameters::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepGeom_SuParameters)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Own fields of SuParameters
+
+ theSW.Send (theEnt->A());
+
+ theSW.Send (theEnt->Alpha());
+
+ theSW.Send (theEnt->B());
+
+ theSW.Send (theEnt->Beta());
+
+ theSW.Send (theEnt->C());
+
+ theSW.Send (theEnt->Gamma());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepGeom_RWSuParameters::Share (const Handle(StepGeom_SuParameters)& /*theEnt*/,
+ Interface_EntityIterator& /*iter*/) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Own fields of SuParameters
+}
--- /dev/null
+// Created on : Sat May 02 12:41:14 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepGeom_RWSuParameters_HeaderFile_
+#define _RWStepGeom_RWSuParameters_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepGeom_SuParameters;
+
+//! Read & Write tool for SuParameters
+class RWStepGeom_RWSuParameters
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepGeom_RWSuParameters();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theAch, const Handle(StepGeom_SuParameters)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepGeom_SuParameters)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepGeom_SuParameters)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepGeom_RWSuParameters_HeaderFile_
--- /dev/null
+RWStepKinematics_RWActuatedKinematicPair.cxx
+RWStepKinematics_RWActuatedKinematicPair.hxx
+RWStepKinematics_RWContextDependentKinematicLinkRepresentation.cxx
+RWStepKinematics_RWContextDependentKinematicLinkRepresentation.hxx
+RWStepKinematics_RWCylindricalPair.cxx
+RWStepKinematics_RWCylindricalPair.hxx
+RWStepKinematics_RWCylindricalPairValue.cxx
+RWStepKinematics_RWCylindricalPairValue.hxx
+RWStepKinematics_RWCylindricalPairWithRange.cxx
+RWStepKinematics_RWCylindricalPairWithRange.hxx
+RWStepKinematics_RWFullyConstrainedPair.cxx
+RWStepKinematics_RWFullyConstrainedPair.hxx
+RWStepKinematics_RWGearPair.cxx
+RWStepKinematics_RWGearPair.hxx
+RWStepKinematics_RWGearPairValue.cxx
+RWStepKinematics_RWGearPairValue.hxx
+RWStepKinematics_RWGearPairWithRange.cxx
+RWStepKinematics_RWGearPairWithRange.hxx
+RWStepKinematics_RWHomokineticPair.cxx
+RWStepKinematics_RWHomokineticPair.hxx
+RWStepKinematics_RWActuatedKinPairAndOrderKinPair.cxx
+RWStepKinematics_RWActuatedKinPairAndOrderKinPair.hxx
+RWStepKinematics_RWKinematicJoint.cxx
+RWStepKinematics_RWKinematicJoint.hxx
+RWStepKinematics_RWKinematicLink.cxx
+RWStepKinematics_RWKinematicLink.hxx
+RWStepKinematics_RWKinematicLinkRepresentationAssociation.cxx
+RWStepKinematics_RWKinematicLinkRepresentationAssociation.hxx
+RWStepKinematics_RWKinematicPropertyMechanismRepresentation.cxx
+RWStepKinematics_RWKinematicPropertyMechanismRepresentation.hxx
+RWStepKinematics_RWKinematicTopologyStructure.cxx
+RWStepKinematics_RWKinematicTopologyStructure.hxx
+RWStepKinematics_RWLinearFlexibleAndPinionPair.cxx
+RWStepKinematics_RWLinearFlexibleAndPinionPair.hxx
+RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair.cxx
+RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair.hxx
+RWStepKinematics_RWLinearFlexibleLinkRepresentation.cxx
+RWStepKinematics_RWLinearFlexibleLinkRepresentation.hxx
+RWStepKinematics_RWLowOrderKinematicPair.cxx
+RWStepKinematics_RWLowOrderKinematicPair.hxx
+RWStepKinematics_RWLowOrderKinematicPairValue.cxx
+RWStepKinematics_RWLowOrderKinematicPairValue.hxx
+RWStepKinematics_RWLowOrderKinematicPairWithRange.cxx
+RWStepKinematics_RWLowOrderKinematicPairWithRange.hxx
+RWStepKinematics_RWMechanismRepresentation.cxx
+RWStepKinematics_RWMechanismRepresentation.hxx
+RWStepKinematics_RWMechanismStateRepresentation.cxx
+RWStepKinematics_RWMechanismStateRepresentation.hxx
+RWStepKinematics_RWOrientedJoint.cxx
+RWStepKinematics_RWOrientedJoint.hxx
+RWStepKinematics_RWPairRepresentationRelationship.cxx
+RWStepKinematics_RWPairRepresentationRelationship.hxx
+RWStepKinematics_RWPlanarCurvePair.cxx
+RWStepKinematics_RWPlanarCurvePair.hxx
+RWStepKinematics_RWPlanarCurvePairRange.cxx
+RWStepKinematics_RWPlanarCurvePairRange.hxx
+RWStepKinematics_RWPlanarPair.cxx
+RWStepKinematics_RWPlanarPair.hxx
+RWStepKinematics_RWPlanarPairValue.cxx
+RWStepKinematics_RWPlanarPairValue.hxx
+RWStepKinematics_RWPlanarPairWithRange.cxx
+RWStepKinematics_RWPlanarPairWithRange.hxx
+RWStepKinematics_RWPointOnPlanarCurvePair.cxx
+RWStepKinematics_RWPointOnPlanarCurvePair.hxx
+RWStepKinematics_RWPointOnPlanarCurvePairValue.cxx
+RWStepKinematics_RWPointOnPlanarCurvePairValue.hxx
+RWStepKinematics_RWPointOnPlanarCurvePairWithRange.cxx
+RWStepKinematics_RWPointOnPlanarCurvePairWithRange.hxx
+RWStepKinematics_RWPointOnSurfacePair.cxx
+RWStepKinematics_RWPointOnSurfacePair.hxx
+RWStepKinematics_RWPointOnSurfacePairValue.cxx
+RWStepKinematics_RWPointOnSurfacePairValue.hxx
+RWStepKinematics_RWPointOnSurfacePairWithRange.cxx
+RWStepKinematics_RWPointOnSurfacePairWithRange.hxx
+RWStepKinematics_RWPrismaticPair.cxx
+RWStepKinematics_RWPrismaticPair.hxx
+RWStepKinematics_RWPrismaticPairValue.cxx
+RWStepKinematics_RWPrismaticPairValue.hxx
+RWStepKinematics_RWPrismaticPairWithRange.cxx
+RWStepKinematics_RWPrismaticPairWithRange.hxx
+RWStepKinematics_RWProductDefinitionKinematics.cxx
+RWStepKinematics_RWProductDefinitionKinematics.hxx
+RWStepKinematics_RWProductDefinitionRelationshipKinematics.cxx
+RWStepKinematics_RWProductDefinitionRelationshipKinematics.hxx
+RWStepKinematics_RWRackAndPinionPair.cxx
+RWStepKinematics_RWRackAndPinionPair.hxx
+RWStepKinematics_RWRackAndPinionPairValue.cxx
+RWStepKinematics_RWRackAndPinionPairValue.hxx
+RWStepKinematics_RWRackAndPinionPairWithRange.cxx
+RWStepKinematics_RWRackAndPinionPairWithRange.hxx
+RWStepKinematics_RWRevolutePair.cxx
+RWStepKinematics_RWRevolutePair.hxx
+RWStepKinematics_RWRevolutePairValue.cxx
+RWStepKinematics_RWRevolutePairValue.hxx
+RWStepKinematics_RWRevolutePairWithRange.cxx
+RWStepKinematics_RWRevolutePairWithRange.hxx
+RWStepKinematics_RWRigidLinkRepresentation.cxx
+RWStepKinematics_RWRigidLinkRepresentation.hxx
+RWStepKinematics_RWRollingCurvePair.cxx
+RWStepKinematics_RWRollingCurvePair.hxx
+RWStepKinematics_RWRollingCurvePairValue.cxx
+RWStepKinematics_RWRollingCurvePairValue.hxx
+RWStepKinematics_RWRollingSurfacePair.cxx
+RWStepKinematics_RWRollingSurfacePair.hxx
+RWStepKinematics_RWRollingSurfacePairValue.cxx
+RWStepKinematics_RWRollingSurfacePairValue.hxx
+RWStepKinematics_RWRotationAboutDirection.cxx
+RWStepKinematics_RWRotationAboutDirection.hxx
+RWStepKinematics_RWScrewPair.cxx
+RWStepKinematics_RWScrewPair.hxx
+RWStepKinematics_RWScrewPairValue.cxx
+RWStepKinematics_RWScrewPairValue.hxx
+RWStepKinematics_RWScrewPairWithRange.cxx
+RWStepKinematics_RWScrewPairWithRange.hxx
+RWStepKinematics_RWSlidingCurvePair.cxx
+RWStepKinematics_RWSlidingCurvePair.hxx
+RWStepKinematics_RWSlidingCurvePairValue.cxx
+RWStepKinematics_RWSlidingCurvePairValue.hxx
+RWStepKinematics_RWSlidingSurfacePair.cxx
+RWStepKinematics_RWSlidingSurfacePair.hxx
+RWStepKinematics_RWSlidingSurfacePairValue.cxx
+RWStepKinematics_RWSlidingSurfacePairValue.hxx
+RWStepKinematics_RWSphericalPair.cxx
+RWStepKinematics_RWSphericalPair.hxx
+RWStepKinematics_RWSphericalPairValue.cxx
+RWStepKinematics_RWSphericalPairValue.hxx
+RWStepKinematics_RWSphericalPairWithPin.cxx
+RWStepKinematics_RWSphericalPairWithPin.hxx
+RWStepKinematics_RWSphericalPairWithPinAndRange.cxx
+RWStepKinematics_RWSphericalPairWithPinAndRange.hxx
+RWStepKinematics_RWSphericalPairWithRange.cxx
+RWStepKinematics_RWSphericalPairWithRange.hxx
+RWStepKinematics_RWSurfacePairWithRange.cxx
+RWStepKinematics_RWSurfacePairWithRange.hxx
+RWStepKinematics_RWKinematicTopologyDirectedStructure.cxx
+RWStepKinematics_RWKinematicTopologyDirectedStructure.hxx
+RWStepKinematics_RWKinematicTopologyNetworkStructure.cxx
+RWStepKinematics_RWKinematicTopologyNetworkStructure.hxx
+RWStepKinematics_RWUnconstrainedPair.cxx
+RWStepKinematics_RWUnconstrainedPair.hxx
+RWStepKinematics_RWUnconstrainedPairValue.cxx
+RWStepKinematics_RWUnconstrainedPairValue.hxx
+RWStepKinematics_RWUniversalPair.cxx
+RWStepKinematics_RWUniversalPair.hxx
+RWStepKinematics_RWUniversalPairValue.cxx
+RWStepKinematics_RWUniversalPairValue.hxx
+RWStepKinematics_RWUniversalPairWithRange.cxx
+RWStepKinematics_RWUniversalPairWithRange.hxx
\ No newline at end of file
--- /dev/null
+// Created on: 2020-05-26
+// Created by: PASUKHIN DMITRY
+// Copyright (c) 2020 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWActuatedKinPairAndOrderKinPair.hxx>
+
+#include <Interface_Check.hxx>
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_ActuatedKinPairAndOrderKinPair.hxx>
+#include <StepKinematics_ActuatedDirection.hxx>
+#include <StepKinematics_ActuatedKinematicPair.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepKinematics_CylindricalPair.hxx>
+#include <StepKinematics_CylindricalPairWithRange.hxx>
+#include <StepKinematics_FullyConstrainedPair.hxx>
+#include <StepKinematics_GearPair.hxx>
+#include <StepKinematics_GearPairWithRange.hxx>
+#include <StepKinematics_HomokineticPair.hxx>
+#include <StepKinematics_KinematicTopologyStructure.hxx>
+#include <StepKinematics_LowOrderKinematicPair.hxx>
+#include <StepKinematics_LowOrderKinematicPairWithRange.hxx>
+#include <StepKinematics_PlanarCurvePair.hxx>
+#include <StepKinematics_PlanarCurvePairRange.hxx>
+#include <StepKinematics_PlanarPair.hxx>
+#include <StepKinematics_PlanarPairWithRange.hxx>
+#include <StepKinematics_PointOnPlanarCurvePair.hxx>
+#include <StepKinematics_PointOnPlanarCurvePairWithRange.hxx>
+#include <StepKinematics_PointOnSurfacePair.hxx>
+#include <StepKinematics_PointOnSurfacePairWithRange.hxx>
+#include <StepKinematics_PrismaticPair.hxx>
+#include <StepKinematics_PrismaticPairWithRange.hxx>
+#include <StepKinematics_ProductDefinitionKinematics.hxx>
+#include <StepKinematics_RackAndPinionPair.hxx>
+#include <StepKinematics_RackAndPinionPairWithRange.hxx>
+#include <StepKinematics_RevolutePair.hxx>
+#include <StepKinematics_RevolutePairWithRange.hxx>
+#include <StepKinematics_RollingCurvePair.hxx>
+#include <StepKinematics_RollingSurfacePair.hxx>
+#include <StepKinematics_ScrewPair.hxx>
+#include <StepKinematics_ScrewPairWithRange.hxx>
+#include <StepKinematics_SlidingCurvePair.hxx>
+#include <StepKinematics_SlidingSurfacePair.hxx>
+#include <StepKinematics_SphericalPair.hxx>
+#include <StepKinematics_SphericalPairWithPin.hxx>
+#include <StepKinematics_SphericalPairWithPinAndRange.hxx>
+#include <StepKinematics_SphericalPairWithRange.hxx>
+#include <StepKinematics_SurfacePairWithRange.hxx>
+#include <StepKinematics_UnconstrainedPair.hxx>
+#include <StepKinematics_UnconstrainedPairValue.hxx>
+#include <StepKinematics_UniversalPair.hxx>
+#include <StepKinematics_UniversalPairWithRange.hxx>
+
+//=======================================================================
+//function : RWStepDimTol_RWGeoTolAndGeoTolWthMod
+//purpose :
+//=======================================================================
+RWStepKinematics_RWActuatedKinPairAndOrderKinPair::RWStepKinematics_RWActuatedKinPairAndOrderKinPair()
+{
+}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWActuatedKinPairAndOrderKinPair::ReadStep
+(const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer num0, Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_ActuatedKinPairAndOrderKinPair)& theEnt) const
+{
+ Standard_Integer theNum = 0;//num0;
+ theData->NamedForComplex("ACTUATED_KINEMATIC_PAIR", "ACKNPR", num0, theNum, theArch);
+ if (!theData->CheckNbParams(theNum, 6, theArch, "kinematic actuated_kinematic_pair")) return;
+ // Own fields of ActuatedKinematicPair
+ Handle(StepKinematics_ActuatedKinematicPair) anActuatedKinematicPair =
+ new StepKinematics_ActuatedKinematicPair;
+ StepKinematics_ActuatedDirection aTX = StepKinematics_adNotActuated;
+ Standard_Boolean hasTX = Standard_True;
+ if (theData->IsParamDefined(theNum, 1))
+ {
+ if (theData->ParamType(theNum, 1) == Interface_ParamEnum)
+ {
+ Standard_CString text = theData->ParamCValue(theNum, 1);
+ if (strcmp(text, ".BIDIRECTIONAL.")) aTX = StepKinematics_adBidirectional;
+ else if (strcmp(text, ".POSITIVE_ONLY.")) aTX = StepKinematics_adPositiveOnly;
+ else if (strcmp(text, ".NEGATIVE_ONLY.")) aTX = StepKinematics_adNegativeOnly;
+ else if (strcmp(text, ".NOT_ACTUATED.")) aTX = StepKinematics_adNotActuated;
+ else theArch->AddFail("Parameter #1 (t_x) has not allowed value");
+ }
+ else theArch->AddFail("Parameter #1 (t_x) is not enumeration");
+ }
+ else
+ {
+ hasTX = Standard_False;
+ }
+
+ StepKinematics_ActuatedDirection aTY = StepKinematics_adNotActuated;
+ Standard_Boolean hasTY = Standard_True;
+ if (theData->IsParamDefined(theNum, 2))
+ {
+ if (theData->ParamType(theNum, 2) == Interface_ParamEnum)
+ {
+ Standard_CString text = theData->ParamCValue(theNum, 8);
+ if (strcmp(text, ".BIDIRECTIONAL.")) aTY = StepKinematics_adBidirectional;
+ else if (strcmp(text, ".POSITIVE_ONLY.")) aTY = StepKinematics_adPositiveOnly;
+ else if (strcmp(text, ".NEGATIVE_ONLY.")) aTY = StepKinematics_adNegativeOnly;
+ else if (strcmp(text, ".NOT_ACTUATED.")) aTY = StepKinematics_adNotActuated;
+ else theArch->AddFail("Parameter #2 (t_y) has not allowed value");
+ }
+ else theArch->AddFail("Parameter #2 (t_y) is not enumeration");
+ }
+ else
+ {
+ hasTY = Standard_False;
+ }
+
+ StepKinematics_ActuatedDirection aTZ = StepKinematics_adNotActuated;
+ Standard_Boolean hasTZ = Standard_True;
+ if (theData->IsParamDefined(theNum, 3))
+ {
+ if (theData->ParamType(theNum, 3) == Interface_ParamEnum)
+ {
+ Standard_CString text = theData->ParamCValue(theNum, 9);
+ if (strcmp(text, ".BIDIRECTIONAL.")) aTZ = StepKinematics_adBidirectional;
+ else if (strcmp(text, ".POSITIVE_ONLY.")) aTZ = StepKinematics_adPositiveOnly;
+ else if (strcmp(text, ".NEGATIVE_ONLY.")) aTZ = StepKinematics_adNegativeOnly;
+ else if (strcmp(text, ".NOT_ACTUATED.")) aTZ = StepKinematics_adNotActuated;
+ else theArch->AddFail("Parameter #3 (t_z) has not allowed value");
+ }
+ else theArch->AddFail("Parameter #3 (t_z) is not enumeration");
+ }
+ else
+ {
+ hasTZ = Standard_False;
+ }
+
+ StepKinematics_ActuatedDirection aRX = StepKinematics_adNotActuated;
+ Standard_Boolean hasRX = Standard_True;
+ if (theData->IsParamDefined(theNum, 4))
+ {
+ if (theData->ParamType(theNum, 4) == Interface_ParamEnum)
+ {
+ Standard_CString text = theData->ParamCValue(theNum, 10);
+ if (strcmp(text, ".BIDIRECTIONAL.")) aRX = StepKinematics_adBidirectional;
+ else if (strcmp(text, ".POSITIVE_ONLY.")) aRX = StepKinematics_adPositiveOnly;
+ else if (strcmp(text, ".NEGATIVE_ONLY.")) aRX = StepKinematics_adNegativeOnly;
+ else if (strcmp(text, ".NOT_ACTUATED.")) aRX = StepKinematics_adNotActuated;
+ else theArch->AddFail("Parameter #14 (r_x) has not allowed value");
+ }
+ else theArch->AddFail("Parameter #14 (r_x) is not enumeration");
+ }
+ else
+ {
+ hasRX = Standard_False;
+ }
+
+ StepKinematics_ActuatedDirection aRY = StepKinematics_adNotActuated;
+ Standard_Boolean hasRY = Standard_True;
+ if (theData->IsParamDefined(theNum, 5))
+ {
+ if (theData->ParamType(theNum, 5) == Interface_ParamEnum)
+ {
+ Standard_CString text = theData->ParamCValue(theNum, 11);
+ if (strcmp(text, ".BIDIRECTIONAL.")) aRY = StepKinematics_adBidirectional;
+ else if (strcmp(text, ".POSITIVE_ONLY.")) aRY = StepKinematics_adPositiveOnly;
+ else if (strcmp(text, ".NEGATIVE_ONLY.")) aRY = StepKinematics_adNegativeOnly;
+ else if (strcmp(text, ".NOT_ACTUATED.")) aRY = StepKinematics_adNotActuated;
+ else theArch->AddFail("Parameter #5 (r_y) has not allowed value");
+ }
+ else theArch->AddFail("Parameter #5 (r_y) is not enumeration");
+ }
+ else
+ {
+ hasRY = Standard_False;
+ }
+
+ StepKinematics_ActuatedDirection aRZ = StepKinematics_adNotActuated;
+ Standard_Boolean hasRZ = Standard_True;
+ if (theData->IsParamDefined(theNum, 6))
+ {
+ if (theData->ParamType(theNum, 6) == Interface_ParamEnum)
+ {
+ Standard_CString text = theData->ParamCValue(theNum, 12);
+ if (strcmp(text, ".BIDIRECTIONAL.")) aRZ = StepKinematics_adBidirectional;
+ else if (strcmp(text, ".POSITIVE_ONLY.")) aRZ = StepKinematics_adPositiveOnly;
+ else if (strcmp(text, ".NEGATIVE_ONLY.")) aRZ = StepKinematics_adNegativeOnly;
+ else if (strcmp(text, ".NOT_ACTUATED.")) aRZ = StepKinematics_adNotActuated;
+ else theArch->AddFail("Parameter #6 (r_z) has not allowed value");
+ }
+ else theArch->AddFail("Parameter #6 (r_z) is not enumeration");
+ }
+ else
+ {
+ hasRZ = Standard_False;
+ }
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->NamedForComplex("GEOMETRIC_REPRESENTATION_ITEM", "GMRPIT", num0, theNum, theArch);
+ //geometricrepresentation_item is non-defined
+
+ theData->NamedForComplex("ITEM_DEFINED_TRANSFORMATION", "ITDFTR", num0, theNum, theArch);
+ // Own fields of item_defined_transformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ if (strcmp(theData->ParamCValue(theNum, 1), "*"))
+ theData->ReadString(theNum, 1, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if (theData->IsParamDefined(theNum, 2))
+ {
+ theData->ReadString(theNum, 2, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else
+ {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity(theNum, 3, "ITEM_DEFINED_TRANSFORMATION", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity(theNum, 4, "ITEM_DEFINED_TRANSFORMATION", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ theData->NamedForComplex("KINEMATIC_PAIR", "KNMPR", num0, theNum, theArch);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity(theNum, 1, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ //Select pair supertype
+ theNum = theData->NextForComplex(theNum);
+ Standard_CString aPairSuperType = theData->CType(theNum);
+ Handle(StepKinematics_KinematicPair) aKinematicPair;
+ if (!strcmp(aPairSuperType, "LOW_ORDER_KINEMATIC_PAIR"))
+ {
+ // Own fields of low_order_kinematic_pair
+ Standard_Boolean aLowOrderKinematicPair_TX = Standard_True;
+ Standard_Boolean aLowOrderKinematicPair_TY = Standard_True;
+ Standard_Boolean aLowOrderKinematicPair_TZ = Standard_True;
+ Standard_Boolean aLowOrderKinematicPair_RX = Standard_True;
+ Standard_Boolean aLowOrderKinematicPair_RY = Standard_True;
+ Standard_Boolean aLowOrderKinematicPair_RZ = Standard_True;
+ if (theData->CheckNbParams(theNum, 6, theArch, "LOW_ORDER_KINEMATIC_PAIR"))
+ {
+ if (strcmp(theData->ParamCValue(theNum, 1), "*"))
+ theData->ReadBoolean(theNum, 1, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX);
+ if (strcmp(theData->ParamCValue(theNum, 2), "*"))
+ theData->ReadBoolean(theNum, 2, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY);
+ if (strcmp(theData->ParamCValue(theNum, 3), "*"))
+ theData->ReadBoolean(theNum, 3, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ);
+ if (strcmp(theData->ParamCValue(theNum, 4), "*"))
+ theData->ReadBoolean(theNum, 4, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX);
+ if (strcmp(theData->ParamCValue(theNum, 5), "*"))
+ theData->ReadBoolean(theNum, 5, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY);
+ if (strcmp(theData->ParamCValue(theNum, 6), "*"))
+ theData->ReadBoolean(theNum, 6, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ);
+ }
+ else theArch->AddFail("The supertype of kinematic pair is not supported");
+ aKinematicPair = new StepKinematics_KinematicPair;
+ aKinematicPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name, hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint);
+ theNum = theData->NextForComplex(theNum);
+ Standard_CString aPairtype = theData->CType(theNum);
+ if (!strcmp(aPairtype, "REVOLUTE_PAIR"))
+ {
+ // Own fields of revolute_pair is non-defined
+
+ if (theData->NamedForComplex("REVOLUTE_PAIR_WITH_RANGE", "RPWR", num0, theNum, theArch))
+ {
+ if (theData->CheckNbParams(theNum, 2, theArch, "REVOLUTE_PAIR_WITH_RANGE"))
+ {
+ // Own fields of revolute_pair_with_range
+ aKinematicPair = new StepKinematics_RevolutePairWithRange;
+ Standard_Real aLowerLimitActualRotation;
+ Standard_Boolean hasLowerLimitActualRotation = Standard_True;
+ if (theData->IsParamDefined(theNum, 1))
+ {
+ theData->ReadReal(theNum, 1, "lower_limit_actual_rotation", theArch, aLowerLimitActualRotation);
+ }
+ else
+ {
+ hasLowerLimitActualRotation = Standard_False;
+ aLowerLimitActualRotation = 0;
+ }
+
+ Standard_Real aUpperLimitActualRotation;
+ Standard_Boolean hasUpperLimitActualRotation = Standard_True;
+ if (theData->IsParamDefined(theNum, 2))
+ {
+ theData->ReadReal(theNum, 2, "upper_limit_actual_rotation", theArch, aUpperLimitActualRotation);
+ }
+ else
+ {
+ hasUpperLimitActualRotation = Standard_False;
+ aUpperLimitActualRotation = 0;
+ }
+ Handle(StepKinematics_RevolutePairWithRange) aLocalPair = Handle(StepKinematics_RevolutePairWithRange)::DownCast(aKinematicPair);
+ // Initialize kinematic_pair
+ aLocalPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ,
+ hasLowerLimitActualRotation,
+ aLowerLimitActualRotation,
+ hasUpperLimitActualRotation,
+ aUpperLimitActualRotation);
+ }
+ else // revolute_pair_with_range hasn't params
+ {
+ aKinematicPair = new StepKinematics_RevolutePair;
+ Handle(StepKinematics_RevolutePair) aLocalPair = Handle(StepKinematics_RevolutePair)::DownCast(aKinematicPair);
+ // Initialize kinematic_pair
+ aLocalPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ);
+ }
+ }
+ }
+ else if (!strcmp(aPairtype, "CYLINDRICAL_PAIR"))
+ {
+ // Own fields of cylindrical_pair is non-defined
+
+ if (theData->NamedForComplex("CYLINDRICAL_PAIR_WITH_RANGE", "CPW0", num0, theNum, theArch))
+ {
+ if (theData->CheckNbParams(theNum, 4, theArch, "CYLINDRICAL_PAIR_WITH_RANGE"))
+ {
+ // Own fields of cylindrical_pair_with_range
+ aKinematicPair = new StepKinematics_CylindricalPairWithRange;
+
+ Standard_Real aLowerLimitActualTranslation;
+ Standard_Boolean hasLowerLimitActualTranslation = Standard_True;
+ if (theData->IsParamDefined(theNum, 1))
+ {
+ theData->ReadReal(theNum, 1, "lower_limit_actual_translation", theArch, aLowerLimitActualTranslation);
+ }
+ else
+ {
+ hasLowerLimitActualTranslation = Standard_False;
+ aLowerLimitActualTranslation = 0;
+ }
+
+ Standard_Real aUpperLimitActualTranslation;
+ Standard_Boolean hasUpperLimitActualTranslation = Standard_True;
+ if (theData->IsParamDefined(theNum, 2))
+ {
+ theData->ReadReal(theNum, 2, "upper_limit_actual_translation", theArch, aUpperLimitActualTranslation);
+ }
+ else
+ {
+ hasUpperLimitActualTranslation = Standard_False;
+ aUpperLimitActualTranslation = 0;
+ }
+
+ Standard_Real aLowerLimitActualRotation;
+ Standard_Boolean hasLowerLimitActualRotation = Standard_True;
+ if (theData->IsParamDefined(theNum, 3))
+ {
+ theData->ReadReal(theNum, 3, "lower_limit_actual_rotation", theArch, aLowerLimitActualRotation);
+ }
+ else
+ {
+ hasLowerLimitActualRotation = Standard_False;
+ aLowerLimitActualRotation = 0;
+ }
+
+ Standard_Real aUpperLimitActualRotation;
+ Standard_Boolean hasUpperLimitActualRotation = Standard_True;
+ if (theData->IsParamDefined(theNum, 4))
+ {
+ theData->ReadReal(theNum, 4, "upper_limit_actual_rotation", theArch, aUpperLimitActualRotation);
+ }
+ else
+ {
+ hasUpperLimitActualRotation = Standard_False;
+ aUpperLimitActualRotation = 0;
+ }
+ Handle(StepKinematics_CylindricalPairWithRange) aLocalPair = Handle(StepKinematics_CylindricalPairWithRange)::DownCast(aKinematicPair);
+ // Initialize kinematic_pair
+ aLocalPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ,
+ hasLowerLimitActualTranslation,
+ aLowerLimitActualTranslation,
+ hasUpperLimitActualTranslation,
+ aUpperLimitActualTranslation,
+ hasLowerLimitActualRotation,
+ aLowerLimitActualRotation,
+ hasUpperLimitActualRotation,
+ aUpperLimitActualRotation);
+ }
+ else // cylindrical_pair_with_range hasn't params
+ {
+ aKinematicPair = new StepKinematics_CylindricalPair;
+ Handle(StepKinematics_CylindricalPair) aLocalPair = Handle(StepKinematics_CylindricalPair)::DownCast(aKinematicPair);
+ // Initialize kinematic_pair
+ aLocalPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ);
+ }
+ }
+ }
+ else if (!strcmp(aPairtype, "SPHERICAL_PAIR"))
+ {
+ // Own fields of cylindrical_pair is non-defined
+
+ if (theData->NamedForComplex("SPHERICAL_PAIR_WITH_RANGE", "SPW0", num0, theNum, theArch))
+ {
+ if (theData->CheckNbParams(theNum, 6, theArch, "SPHERICAL_PAIR_WITH_RANGE"))
+ {
+ // Own fields of spherical_pair_with_range
+ aKinematicPair = new StepKinematics_SphericalPairWithRange;
+
+ Standard_Real aLowerLimitYaw;
+ Standard_Boolean hasLowerLimitYaw = Standard_True;
+ if (theData->IsParamDefined(theNum, 1))
+ {
+ theData->ReadReal(theNum, 1, "lower_limit_yaw", theArch, aLowerLimitYaw);
+ }
+ else
+ {
+ hasLowerLimitYaw = Standard_False;
+ aLowerLimitYaw = 0;
+ }
+
+ Standard_Real aUpperLimitYaw;
+ Standard_Boolean hasUpperLimitYaw = Standard_True;
+ if (theData->IsParamDefined(theNum, 2))
+ {
+ theData->ReadReal(theNum, 2, "upper_limit_yaw", theArch, aUpperLimitYaw);
+ }
+ else
+ {
+ hasUpperLimitYaw = Standard_False;
+ aUpperLimitYaw = 0;
+ }
+
+ Standard_Real aLowerLimitPitch;
+ Standard_Boolean hasLowerLimitPitch = Standard_True;
+ if (theData->IsParamDefined(theNum, 3))
+ {
+ theData->ReadReal(theNum, 3, "lower_limit_pitch", theArch, aLowerLimitPitch);
+ }
+ else
+ {
+ hasLowerLimitPitch = Standard_False;
+ aLowerLimitPitch = 0;
+ }
+
+ Standard_Real aUpperLimitPitch;
+ Standard_Boolean hasUpperLimitPitch = Standard_True;
+ if (theData->IsParamDefined(theNum, 4))
+ {
+ theData->ReadReal(theNum, 4, "upper_limit_pitch", theArch, aUpperLimitPitch);
+ }
+ else
+ {
+ hasUpperLimitPitch = Standard_False;
+ aUpperLimitPitch = 0;
+ }
+
+ Standard_Real aLowerLimitRoll;
+ Standard_Boolean hasLowerLimitRoll = Standard_True;
+ if (theData->IsParamDefined(theNum, 5))
+ {
+ theData->ReadReal(theNum, 5, "lower_limit_roll", theArch, aLowerLimitRoll);
+ }
+ else
+ {
+ hasLowerLimitRoll = Standard_False;
+ aLowerLimitRoll = 0;
+ }
+
+ Standard_Real aUpperLimitRoll;
+ Standard_Boolean hasUpperLimitRoll = Standard_True;
+ if (theData->IsParamDefined(theNum, 6))
+ {
+ theData->ReadReal(theNum, 6, "upper_limit_roll", theArch, aUpperLimitRoll);
+ }
+ else
+ {
+ hasUpperLimitRoll = Standard_False;
+ aUpperLimitRoll = 0;
+ }
+ Handle(StepKinematics_SphericalPairWithRange) aLocalPair = Handle(StepKinematics_SphericalPairWithRange)::DownCast(aKinematicPair);
+ // Initialize kinematic_pair
+ aLocalPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ,
+ hasLowerLimitYaw,
+ aLowerLimitYaw,
+ hasUpperLimitYaw,
+ aUpperLimitYaw,
+ hasLowerLimitPitch,
+ aLowerLimitPitch,
+ hasUpperLimitPitch,
+ aUpperLimitPitch,
+ hasLowerLimitRoll,
+ aLowerLimitRoll,
+ hasUpperLimitRoll,
+ aUpperLimitRoll);
+ }
+ else // spherical_pair_with_range hasn't params
+ {
+ aKinematicPair = new StepKinematics_SphericalPair;
+ Handle(StepKinematics_SphericalPair) aLocalPair = Handle(StepKinematics_SphericalPair)::DownCast(aKinematicPair);
+ // Initialize kinematic_pair
+ aLocalPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ);
+ }
+ }
+ }
+ else if (!strcmp(aPairtype, "SPHERICAL_PAIR_WITH_PIN"))
+ {
+ // Own fields of spherical_pair_with_pin is non-defined
+
+ if (theData->NamedForComplex("SPHERICAL_PAIR_WITH_PIN_AND_RANGE", "SPWPAR", num0, theNum, theArch))
+ {
+ if (theData->CheckNbParams(theNum, 4, theArch, "SPHERICAL_PAIR_WITH_PIN_AND_RANGE"))
+ {
+ // Own fields of spherical_pair_with_pin_and_range
+ aKinematicPair = new StepKinematics_SphericalPairWithPinAndRange;
+
+
+ Standard_Real aLowerLimitYaw;
+ Standard_Boolean hasLowerLimitYaw = Standard_True;
+ if (theData->IsParamDefined(theNum, 1))
+ {
+ theData->ReadReal(theNum, 1, "lower_limit_yaw", theArch, aLowerLimitYaw);
+ }
+ else
+ {
+ hasLowerLimitYaw = Standard_False;
+ aLowerLimitYaw = 0;
+ }
+
+ Standard_Real aUpperLimitYaw;
+ Standard_Boolean hasUpperLimitYaw = Standard_True;
+ if (theData->IsParamDefined(theNum, 2))
+ {
+ theData->ReadReal(theNum, 2, "upper_limit_yaw", theArch, aUpperLimitYaw);
+ }
+ else
+ {
+ hasUpperLimitYaw = Standard_False;
+ aUpperLimitYaw = 0;
+ }
+
+ Standard_Real aLowerLimitRoll;
+ Standard_Boolean hasLowerLimitRoll = Standard_True;
+ if (theData->IsParamDefined(theNum, 3))
+ {
+ theData->ReadReal(theNum, 3, "lower_limit_roll", theArch, aLowerLimitRoll);
+ }
+ else
+ {
+ hasLowerLimitRoll = Standard_False;
+ aLowerLimitRoll = 0;
+ }
+
+ Standard_Real aUpperLimitRoll;
+ Standard_Boolean hasUpperLimitRoll = Standard_True;
+ if (theData->IsParamDefined(theNum, 4))
+ {
+ theData->ReadReal(theNum, 4, "upper_limit_roll", theArch, aUpperLimitRoll);
+ }
+ else
+ {
+ hasUpperLimitRoll = Standard_False;
+ aUpperLimitRoll = 0;
+ }
+ Handle(StepKinematics_SphericalPairWithPinAndRange) aLocalPair = Handle(StepKinematics_SphericalPairWithPinAndRange)::DownCast(aKinematicPair);
+ // Initialize kinematic_pair
+ aLocalPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ,
+ hasLowerLimitYaw,
+ aLowerLimitYaw,
+ hasUpperLimitYaw,
+ aUpperLimitYaw,
+ hasLowerLimitRoll,
+ aLowerLimitRoll,
+ hasUpperLimitRoll,
+ aUpperLimitRoll);
+ }
+ else // spherical_pair_with_pin_and_range hasn't params
+ {
+ aKinematicPair = new StepKinematics_SphericalPairWithPin;
+ Handle(StepKinematics_SphericalPairWithPin) aLocalPair = Handle(StepKinematics_SphericalPairWithPin)::DownCast(aKinematicPair);
+ // Initialize kinematic_pair
+ aLocalPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ);
+ }
+ }
+ else theArch->AddFail("The type of kinematic pair with range is not supported");
+ }
+ else if (!strcmp(aPairtype, "PRISMATIC_PAIR"))
+ {
+ // Own fields of prismatic_pair is non-defined
+
+ if (theData->NamedForComplex("PRISMATIC_PAIR_WITH_RANGE", "PPW0", num0, theNum, theArch))
+ {
+ if (theData->CheckNbParams(theNum, 2, theArch, "PRISMATIC_PAIR_WITH_RANGE"))
+ {
+ aKinematicPair = new StepKinematics_PrismaticPairWithRange;
+ // Own fields of prismatic_pair_with_range
+
+ Standard_Real aLowerLimitActualTranslation;
+ Standard_Boolean hasLowerLimitActualTranslation = Standard_True;
+ if (theData->IsParamDefined(theNum, 1))
+ {
+ theData->ReadReal(theNum, 1, "lower_limit_actual_translation", theArch, aLowerLimitActualTranslation);
+ }
+ else
+ {
+ hasLowerLimitActualTranslation = Standard_False;
+ aLowerLimitActualTranslation = 0;
+ }
+
+ Standard_Real aUpperLimitActualTranslation;
+ Standard_Boolean hasUpperLimitActualTranslation = Standard_True;
+ if (theData->IsParamDefined(theNum, 2))
+ {
+ theData->ReadReal(theNum, 2, "upper_limit_actual_translation", theArch, aUpperLimitActualTranslation);
+ }
+ else
+ {
+ hasUpperLimitActualTranslation = Standard_False;
+ aUpperLimitActualTranslation = 0;
+ }
+ Handle(StepKinematics_PrismaticPairWithRange) aLocalPair = Handle(StepKinematics_PrismaticPairWithRange)::DownCast(aKinematicPair);
+ // Initialize kinematic_pair
+ aLocalPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ,
+ hasLowerLimitActualTranslation,
+ aLowerLimitActualTranslation,
+ hasUpperLimitActualTranslation,
+ aUpperLimitActualTranslation);
+ }
+ else // prismatic_pair_with_range hasn't params
+ {
+ aKinematicPair = new StepKinematics_PrismaticPair;
+ Handle(StepKinematics_PrismaticPair) aLocalPair = Handle(StepKinematics_PrismaticPair)::DownCast(aKinematicPair);
+ // Initialize kinematic_pair
+ aLocalPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ);
+ }
+ }
+ }
+ else if (!strcmp(aPairtype, "UNIVERSAL_PAIR"))
+ {
+ // Own fields of universal_pair
+
+ aKinematicPair = new StepKinematics_UniversalPair;
+ Standard_Real aInputSkewAngle;
+ Standard_Boolean hasInputSkewAngle = Standard_True;
+ if (theData->IsParamDefined(theNum, 1))
+ {
+ theData->ReadReal(theNum, 1, "input_skew_angle", theArch, aInputSkewAngle);
+ }
+ else
+ {
+ hasInputSkewAngle = Standard_False;
+ aInputSkewAngle = 0;
+ }
+
+ if (theData->NamedForComplex("UNIVERSAL_PAIR_WITH_RANGE", "UPWR", num0, theNum, theArch))
+ {
+ if (theData->CheckNbParams(theNum, 4, theArch, "UNIVERSAL_PAIR_WITH_RANGE"))
+ {
+ // Own fields of universal_pair_with_range
+
+ Standard_Real aLowerLimitFirstRotation;
+ Standard_Boolean hasLowerLimitFirstRotation = Standard_True;
+ if (theData->IsParamDefined(theNum, 1))
+ {
+ theData->ReadReal(theNum, 1, "lower_limit_first_rotation", theArch, aLowerLimitFirstRotation);
+ }
+ else
+ {
+ hasLowerLimitFirstRotation = Standard_False;
+ aLowerLimitFirstRotation = 0;
+ }
+
+ Standard_Real aUpperLimitFirstRotation;
+ Standard_Boolean hasUpperLimitFirstRotation = Standard_True;
+ if (theData->IsParamDefined(theNum, 2))
+ {
+ theData->ReadReal(theNum, 2, "upper_limit_first_rotation", theArch, aUpperLimitFirstRotation);
+ }
+ else
+ {
+ hasUpperLimitFirstRotation = Standard_False;
+ aUpperLimitFirstRotation = 0;
+ }
+
+ Standard_Real aLowerLimitSecondRotation;
+ Standard_Boolean hasLowerLimitSecondRotation = Standard_True;
+ if (theData->IsParamDefined(theNum, 3))
+ {
+ theData->ReadReal(theNum, 3, "lower_limit_second_rotation", theArch, aLowerLimitSecondRotation);
+ }
+ else
+ {
+ hasLowerLimitSecondRotation = Standard_False;
+ aLowerLimitSecondRotation = 0;
+ }
+
+ Standard_Real aUpperLimitSecondRotation;
+ Standard_Boolean hasUpperLimitSecondRotation = Standard_True;
+ if (theData->IsParamDefined(theNum, 4))
+ {
+ theData->ReadReal(theNum, 4, "upper_limit_second_rotation", theArch, aUpperLimitSecondRotation);
+ }
+ else
+ {
+ hasUpperLimitSecondRotation = Standard_False;
+ aUpperLimitSecondRotation = 0;
+ }
+ aKinematicPair = new StepKinematics_UniversalPairWithRange;
+ Handle(StepKinematics_UniversalPairWithRange) aLocalPair = Handle(StepKinematics_UniversalPairWithRange)::DownCast(aKinematicPair);
+ // Initialize kinematic_pair
+ aLocalPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ,
+ hasInputSkewAngle,
+ aInputSkewAngle,
+ hasLowerLimitFirstRotation,
+ aLowerLimitFirstRotation,
+ hasUpperLimitFirstRotation,
+ aUpperLimitFirstRotation,
+ hasLowerLimitSecondRotation,
+ aLowerLimitSecondRotation,
+ hasUpperLimitSecondRotation,
+ aUpperLimitSecondRotation);
+ }
+ else // universal_pair_with_range hasn't params
+ {
+ aKinematicPair = new StepKinematics_UniversalPair;
+ Handle(StepKinematics_UniversalPair) aLocalPair = Handle(StepKinematics_UniversalPair)::DownCast(aKinematicPair);
+ // Initialize kinematic_pair
+ aLocalPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ,
+ hasInputSkewAngle,
+ aInputSkewAngle);
+ }
+ }
+ }
+ else if (!strcmp(aPairtype, "PLANAR_PAIR"))
+ {
+ // Own fields of planar_pair is non-defined
+
+ if (theData->NamedForComplex("PLANAR_PAIR_WITH_RANGE", "PPWR", num0, theNum, theArch))
+ {
+ if (theData->CheckNbParams(theNum, 6, theArch, "UNIVERSAL_PAIR_WITH_RANGE"))
+ {
+ // Own fields of universal_pair_with_range
+
+ aKinematicPair = new StepKinematics_PlanarPairWithRange;
+ Standard_Real aLowerLimitActualRotation;
+ Standard_Boolean hasLowerLimitActualRotation = Standard_True;
+ if (theData->IsParamDefined(theNum, 1))
+ {
+ theData->ReadReal(theNum, 1, "lower_limit_actual_rotation", theArch, aLowerLimitActualRotation);
+ }
+ else
+ {
+ hasLowerLimitActualRotation = Standard_False;
+ aLowerLimitActualRotation = 0;
+ }
+
+ Standard_Real aUpperLimitActualRotation;
+ Standard_Boolean hasUpperLimitActualRotation = Standard_True;
+ if (theData->IsParamDefined(theNum, 2))
+ {
+ theData->ReadReal(theNum, 2, "upper_limit_actual_rotation", theArch, aUpperLimitActualRotation);
+ }
+ else
+ {
+ hasUpperLimitActualRotation = Standard_False;
+ aUpperLimitActualRotation = 0;
+ }
+
+ Standard_Real aLowerLimitActualTranslationX;
+ Standard_Boolean hasLowerLimitActualTranslationX = Standard_True;
+ if (theData->IsParamDefined(theNum, 3))
+ {
+ theData->ReadReal(theNum, 3, "lower_limit_actual_translation_x", theArch, aLowerLimitActualTranslationX);
+ }
+ else
+ {
+ hasLowerLimitActualTranslationX = Standard_False;
+ aLowerLimitActualTranslationX = 0;
+ }
+
+ Standard_Real aUpperLimitActualTranslationX;
+ Standard_Boolean hasUpperLimitActualTranslationX = Standard_True;
+ if (theData->IsParamDefined(theNum, 4))
+ {
+ theData->ReadReal(theNum, 4, "upper_limit_actual_translation_x", theArch, aUpperLimitActualTranslationX);
+ }
+ else
+ {
+ hasUpperLimitActualTranslationX = Standard_False;
+ aUpperLimitActualTranslationX = 0;
+ }
+
+ Standard_Real aLowerLimitActualTranslationY;
+ Standard_Boolean hasLowerLimitActualTranslationY = Standard_True;
+ if (theData->IsParamDefined(theNum, 5))
+ {
+ theData->ReadReal(theNum, 5, "lower_limit_actual_translation_y", theArch, aLowerLimitActualTranslationY);
+ }
+ else
+ {
+ hasLowerLimitActualTranslationY = Standard_False;
+ aLowerLimitActualTranslationY = 0;
+ }
+
+ Standard_Real aUpperLimitActualTranslationY;
+ Standard_Boolean hasUpperLimitActualTranslationY = Standard_True;
+ if (theData->IsParamDefined(theNum, 6))
+ {
+ theData->ReadReal(theNum, 6, "upper_limit_actual_translation_y", theArch, aUpperLimitActualTranslationY);
+ }
+ else
+ {
+ hasUpperLimitActualTranslationY = Standard_False;
+ aUpperLimitActualTranslationY = 0;
+ }
+ Handle(StepKinematics_PlanarPairWithRange) aLocalPair = Handle(StepKinematics_PlanarPairWithRange)::DownCast(aKinematicPair);
+ // Initialize kinematic_pair
+ aLocalPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ,
+ hasLowerLimitActualRotation,
+ aLowerLimitActualRotation,
+ hasUpperLimitActualRotation,
+ aUpperLimitActualRotation,
+ hasLowerLimitActualTranslationX,
+ aLowerLimitActualTranslationX,
+ hasUpperLimitActualTranslationX,
+ aUpperLimitActualTranslationX,
+ hasLowerLimitActualTranslationY,
+ aLowerLimitActualTranslationY,
+ hasUpperLimitActualTranslationY,
+ aUpperLimitActualTranslationY);
+ }
+ else // universal_pair_with_range hasn't params
+ {
+ aKinematicPair = new StepKinematics_PlanarPair;
+ Handle(StepKinematics_PlanarPair) aLocalPair = Handle(StepKinematics_PlanarPair)::DownCast(aKinematicPair);
+ // Initialize kinematic_pair
+ aLocalPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ);
+ }
+ }
+ }
+ }
+ else if (!strcmp(aPairSuperType, "LOW_ORDER_KINEMATIC_PAIR_WITH_MOTION_COUPLING"))
+ {
+ theNum = theData->NextForComplex(theNum);
+ Standard_CString aPairtype = theData->CType(theNum);
+ if (!strcmp(aPairtype, "GEAR_PAIR"))
+ {
+
+ // Inherited fields of GearPair
+
+ Standard_Real aGearPair_RadiusFirstLink;
+ theData->ReadReal(theNum, 1, "gear_pair.radius_first_link", theArch, aGearPair_RadiusFirstLink);
+
+ Standard_Real aGearPair_RadiusSecondLink;
+ theData->ReadReal(theNum, 2, "gear_pair.radius_second_link", theArch, aGearPair_RadiusSecondLink);
+
+ Standard_Real aGearPair_Bevel;
+ theData->ReadReal(theNum, 3, "gear_pair.bevel", theArch, aGearPair_Bevel);
+
+ Standard_Real aGearPair_HelicalAngle;
+ theData->ReadReal(theNum, 4, "gear_pair.helical_angle", theArch, aGearPair_HelicalAngle);
+
+ Standard_Real aGearPair_GearRatio;
+ theData->ReadReal(theNum, 5, "gear_pair.gear_ratio", theArch, aGearPair_GearRatio);
+
+ if (theData->NamedForComplex("GEAR_PAIR_WITH_RANGE", "GPWR", num0, theNum, theArch))
+ {
+ if (theData->CheckNbParams(theNum, 2, theArch, "GEAR_PAIR_WITH_RANGE"))
+ {
+ // Own fields of GearPairWithRange
+
+ aKinematicPair = new StepKinematics_GearPairWithRange;
+
+ Standard_Real aLowerLimitActualRotation1;
+ Standard_Boolean hasLowerLimitActualRotation1 = Standard_True;
+ if (theData->IsParamDefined(theNum, 1))
+ {
+ theData->ReadReal(theNum, 1, "lower_limit_actual_rotation1", theArch, aLowerLimitActualRotation1);
+ }
+ else
+ {
+ hasLowerLimitActualRotation1 = Standard_False;
+ aLowerLimitActualRotation1 = 0;
+ }
+
+ Standard_Real aUpperLimitActualRotation1;
+ Standard_Boolean hasUpperLimitActualRotation1 = Standard_True;
+ if (theData->IsParamDefined(theNum, 2))
+ {
+ theData->ReadReal(theNum, 2, "upper_limit_actual_rotation1", theArch, aUpperLimitActualRotation1);
+ }
+ else
+ {
+ hasUpperLimitActualRotation1 = Standard_False;
+ aUpperLimitActualRotation1 = 0;
+ }
+ Handle(StepKinematics_GearPairWithRange) aLocalPair = Handle(StepKinematics_GearPairWithRange)::DownCast(aKinematicPair);
+ // Initialize kinematic_pair
+ aLocalPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aGearPair_RadiusFirstLink,
+ aGearPair_RadiusSecondLink,
+ aGearPair_Bevel,
+ aGearPair_HelicalAngle,
+ aGearPair_GearRatio,
+ hasLowerLimitActualRotation1,
+ aLowerLimitActualRotation1,
+ hasUpperLimitActualRotation1,
+ aUpperLimitActualRotation1);
+
+ }
+ else // StepKinematics_GearPairWithRange hasn't params
+ {
+ aKinematicPair = new StepKinematics_GearPair;
+ Handle(StepKinematics_GearPair) aLocalPair = Handle(StepKinematics_GearPair)::DownCast(aKinematicPair);
+ // Initialize kinematic_pair
+ aLocalPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aGearPair_RadiusFirstLink,
+ aGearPair_RadiusSecondLink,
+ aGearPair_Bevel,
+ aGearPair_HelicalAngle,
+ aGearPair_GearRatio);
+ }
+ }
+ }
+ else if (!strcmp(aPairtype, "RACK_AND_PINION_PAIR"))
+ {
+
+ // Inherited fields of RackAndPinionPair
+ Standard_Real aRackAndPinionPair_PinionRadius;
+ theData->ReadReal(theNum, 1, "rack_and_pinion_pair.pinion_radius", theArch, aRackAndPinionPair_PinionRadius);
+
+ if (theData->NamedForComplex("RACK_AND_PINION_PAIR_WITH_RANGE", "RAPPWR", num0, theNum, theArch))
+ {
+ if (theData->CheckNbParams(theNum, 2, theArch, "RACK_AND_PINION_PAIR_WITH_RANGE"))
+ {
+ // Own fields of GearPairWithRange
+
+ aKinematicPair = new StepKinematics_RackAndPinionPairWithRange;
+
+
+ Standard_Real aLowerLimitRackDisplacement;
+ Standard_Boolean hasLowerLimitRackDisplacement = Standard_True;
+ if (theData->IsParamDefined(theNum, 1))
+ {
+ theData->ReadReal(theNum, 1, "lower_limit_rack_displacement", theArch, aLowerLimitRackDisplacement);
+ }
+ else
+ {
+ hasLowerLimitRackDisplacement = Standard_False;
+ aLowerLimitRackDisplacement = 0;
+ }
+
+ Standard_Real aUpperLimitRackDisplacement;
+ Standard_Boolean hasUpperLimitRackDisplacement = Standard_True;
+ if (theData->IsParamDefined(theNum, 2))
+ {
+ theData->ReadReal(theNum, 2, "upper_limit_rack_displacement", theArch, aUpperLimitRackDisplacement);
+ }
+ else
+ {
+ hasUpperLimitRackDisplacement = Standard_False;
+ aUpperLimitRackDisplacement = 0;
+ }
+
+ Handle(StepKinematics_RackAndPinionPairWithRange) aLocalPair = Handle(StepKinematics_RackAndPinionPairWithRange)::DownCast(aKinematicPair);
+ // Initialize kinematic_pair
+ aLocalPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aRackAndPinionPair_PinionRadius,
+ hasLowerLimitRackDisplacement,
+ aLowerLimitRackDisplacement,
+ hasUpperLimitRackDisplacement,
+ aUpperLimitRackDisplacement);
+ }
+ else // StepKinematics_RackAndPinionPairWithRange hasn't params
+ {
+ aKinematicPair = new StepKinematics_RackAndPinionPair;
+ Handle(StepKinematics_RackAndPinionPair) aLocalPair = Handle(StepKinematics_RackAndPinionPair)::DownCast(aKinematicPair);
+ // Initialize kinematic_pair
+ aLocalPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aRackAndPinionPair_PinionRadius);
+ }
+ }
+ }
+ else if (!strcmp(aPairtype, "SCREW_PAIR"))
+ {
+ // Inherited fields of ScrewPair
+
+ Standard_Real aScrewPair_Pitch;
+ theData->ReadReal(theNum, 1, "screw_pair.pitch", theArch, aScrewPair_Pitch);
+
+ if (theData->NamedForComplex("SCREW_PAIR_WITH_RANGE", "SPWR", num0, theNum, theArch))
+ {
+ if (theData->CheckNbParams(theNum, 2, theArch, "SCREW_PAIR_WITH_RANGE"))
+ {
+ // Own fields of ScrewPairWithRange
+
+ aKinematicPair = new StepKinematics_ScrewPairWithRange;
+ Standard_Real aLowerLimitActualRotation;
+ Standard_Boolean hasLowerLimitActualRotation = Standard_True;
+ if (theData->IsParamDefined(theNum, 1))
+ {
+ theData->ReadReal(theNum, 1, "lower_limit_actual_rotation", theArch, aLowerLimitActualRotation);
+ }
+ else
+ {
+ hasLowerLimitActualRotation = Standard_False;
+ aLowerLimitActualRotation = 0;
+ }
+
+ Standard_Real aUpperLimitActualRotation;
+ Standard_Boolean hasUpperLimitActualRotation = Standard_True;
+ if (theData->IsParamDefined(theNum, 2))
+ {
+ theData->ReadReal(theNum, 2, "upper_limit_actual_rotation", theArch, aUpperLimitActualRotation);
+ }
+ else
+ {
+ hasUpperLimitActualRotation = Standard_False;
+ aUpperLimitActualRotation = 0;
+ }
+
+ Handle(StepKinematics_ScrewPairWithRange) aLocalPair = Handle(StepKinematics_ScrewPairWithRange)::DownCast(aKinematicPair);
+ // Initialize kinematic_pair
+ aLocalPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aScrewPair_Pitch,
+ hasLowerLimitActualRotation,
+ aLowerLimitActualRotation,
+ hasUpperLimitActualRotation,
+ aUpperLimitActualRotation);
+ }
+ else // StepKinematics_ScrewPairWithRange hasn't params
+ {
+ aKinematicPair = new StepKinematics_ScrewPair;
+ Handle(StepKinematics_ScrewPair) aLocalPair = Handle(StepKinematics_ScrewPair)::DownCast(aKinematicPair);
+ // Initialize kinematic_pair
+ aLocalPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aScrewPair_Pitch);
+ }
+ }
+ }
+ }
+ else // "HIGH_ORDER_KINEMATIC_PAIR"
+ {
+ theNum = theData->NextForComplex(theNum);
+ Standard_CString aPairtype = theData->CType(theNum);
+ if (!strcmp(aPairtype, "POINT_ON_PLANAR_CURVE_PAIR"))
+ {
+
+ // Inherited fields of PointOnPlanarCurvePair
+
+ Handle(StepGeom_Curve) aPointOnPlanarCurvePair_PairCurve;
+ theData->ReadEntity(theNum, 1, "point_on_planar_curve_pair.pair_curve", theArch, STANDARD_TYPE(StepGeom_Curve), aPointOnPlanarCurvePair_PairCurve);
+
+ Standard_Boolean aPointOnPlanarCurvePair_Orientation;
+ theData->ReadBoolean(theNum, 2, "point_on_planar_curve_pair.orientation", theArch, aPointOnPlanarCurvePair_Orientation);
+
+
+ if (theData->NamedForComplex("POINT_ON_PLANAR_CURVE_PAIR_WITH_RANGE", "POPCPW", num0, theNum, theArch))
+ {
+ if (theData->CheckNbParams(theNum, 7, theArch, "POINT_ON_PLANAR_CURVE_PAIR_WITH_RANGE"))
+ {
+ // Own fields of PointOnPlanarCurvePairWithRange
+
+ aKinematicPair = new StepKinematics_PointOnPlanarCurvePairWithRange;
+
+ Handle(StepGeom_TrimmedCurve) aRangeOnPairCurve;
+ theData->ReadEntity(theNum, 1, "range_on_pair_curve", theArch, STANDARD_TYPE(StepGeom_TrimmedCurve), aRangeOnPairCurve);
+
+ Standard_Real aLowerLimitYaw;
+ Standard_Boolean hasLowerLimitYaw = Standard_True;
+ if (theData->IsParamDefined(theNum, 2))
+ {
+ theData->ReadReal(theNum, 2, "lower_limit_yaw", theArch, aLowerLimitYaw);
+ }
+ else
+ {
+ hasLowerLimitYaw = Standard_False;
+ aLowerLimitYaw = 0;
+ }
+
+ Standard_Real aUpperLimitYaw;
+ Standard_Boolean hasUpperLimitYaw = Standard_True;
+ if (theData->IsParamDefined(theNum, 3))
+ {
+ theData->ReadReal(theNum, 3, "upper_limit_yaw", theArch, aUpperLimitYaw);
+ }
+ else
+ {
+ hasUpperLimitYaw = Standard_False;
+ aUpperLimitYaw = 0;
+ }
+
+ Standard_Real aLowerLimitPitch;
+ Standard_Boolean hasLowerLimitPitch = Standard_True;
+ if (theData->IsParamDefined(theNum, 4))
+ {
+ theData->ReadReal(theNum, 4, "lower_limit_pitch", theArch, aLowerLimitPitch);
+ }
+ else
+ {
+ hasLowerLimitPitch = Standard_False;
+ aLowerLimitPitch = 0;
+ }
+
+ Standard_Real aUpperLimitPitch;
+ Standard_Boolean hasUpperLimitPitch = Standard_True;
+ if (theData->IsParamDefined(theNum, 5))
+ {
+ theData->ReadReal(theNum, 5, "upper_limit_pitch", theArch, aUpperLimitPitch);
+ }
+ else
+ {
+ hasUpperLimitPitch = Standard_False;
+ aUpperLimitPitch = 0;
+ }
+
+ Standard_Real aLowerLimitRoll;
+ Standard_Boolean hasLowerLimitRoll = Standard_True;
+ if (theData->IsParamDefined(theNum, 6))
+ {
+ theData->ReadReal(theNum, 6, "lower_limit_roll", theArch, aLowerLimitRoll);
+ }
+ else
+ {
+ hasLowerLimitRoll = Standard_False;
+ aLowerLimitRoll = 0;
+ }
+
+ Standard_Real aUpperLimitRoll;
+ Standard_Boolean hasUpperLimitRoll = Standard_True;
+ if (theData->IsParamDefined(theNum, 7))
+ {
+ theData->ReadReal(theNum, 7, "upper_limit_roll", theArch, aUpperLimitRoll);
+ }
+ else
+ {
+ hasUpperLimitRoll = Standard_False;
+ aUpperLimitRoll = 0;
+ }
+ Handle(StepKinematics_PointOnPlanarCurvePairWithRange) aLocalPair = Handle(StepKinematics_PointOnPlanarCurvePairWithRange)::DownCast(aKinematicPair);
+ // Initialize kinematic_pair
+ aLocalPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aPointOnPlanarCurvePair_PairCurve,
+ aPointOnPlanarCurvePair_Orientation,
+ aRangeOnPairCurve,
+ hasLowerLimitYaw,
+ aLowerLimitYaw,
+ hasUpperLimitYaw,
+ aUpperLimitYaw,
+ hasLowerLimitPitch,
+ aLowerLimitPitch,
+ hasUpperLimitPitch,
+ aUpperLimitPitch,
+ hasLowerLimitRoll,
+ aLowerLimitRoll,
+ hasUpperLimitRoll,
+ aUpperLimitRoll);
+
+ }
+ else // point_on_planar_curve_pair_with_range hasn't params
+ {
+ aKinematicPair = new StepKinematics_PointOnPlanarCurvePair;
+ Handle(StepKinematics_PointOnPlanarCurvePair) aLocalPair = Handle(StepKinematics_PointOnPlanarCurvePair)::DownCast(aKinematicPair);
+ // Initialize kinematic_pair
+ aLocalPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aPointOnPlanarCurvePair_PairCurve,
+ aPointOnPlanarCurvePair_Orientation);
+ }
+ }
+ }
+ else if (!strcmp(aPairtype, "POINT_ON_SURFACE_PAIR"))
+ {
+ // Inherited fields of PointOnSurfacePair
+
+ Handle(StepGeom_Surface) aPointOnSurfacePair_PairSurface;
+ theData->ReadEntity(theNum, 1, "point_on_surface_pair.pair_surface", theArch, STANDARD_TYPE(StepGeom_Surface), aPointOnSurfacePair_PairSurface);
+
+ if (theData->NamedForComplex("POINT_ON_SURFACE_PAIR_WITH_RANGE ", "RAPPWR", num0, theNum, theArch))
+ {
+ if (theData->CheckNbParams(theNum, 2, theArch, "POINT_ON_SURFACE_PAIR_WITH_RANGE "))
+ {
+ // Own fields of PointOnSurfacePairWithRange
+
+ aKinematicPair = new StepKinematics_PointOnSurfacePairWithRange;
+
+
+ Handle(StepGeom_RectangularTrimmedSurface) aRangeOnPairSurface;
+ theData->ReadEntity(theNum, 1, "range_on_pair_surface", theArch, STANDARD_TYPE(StepGeom_RectangularTrimmedSurface), aRangeOnPairSurface);
+
+ Standard_Real aLowerLimitYaw;
+ Standard_Boolean hasLowerLimitYaw = Standard_True;
+ if (theData->IsParamDefined(theNum, 2))
+ {
+ theData->ReadReal(theNum, 2, "lower_limit_yaw", theArch, aLowerLimitYaw);
+ }
+ else
+ {
+ hasLowerLimitYaw = Standard_False;
+ aLowerLimitYaw = 0;
+ }
+
+ Standard_Real aUpperLimitYaw;
+ Standard_Boolean hasUpperLimitYaw = Standard_True;
+ if (theData->IsParamDefined(theNum, 3))
+ {
+ theData->ReadReal(theNum, 3, "upper_limit_yaw", theArch, aUpperLimitYaw);
+ }
+ else
+ {
+ hasUpperLimitYaw = Standard_False;
+ aUpperLimitYaw = 0;
+ }
+
+ Standard_Real aLowerLimitPitch;
+ Standard_Boolean hasLowerLimitPitch = Standard_True;
+ if (theData->IsParamDefined(theNum, 4))
+ {
+ theData->ReadReal(theNum, 4, "lower_limit_pitch", theArch, aLowerLimitPitch);
+ }
+ else
+ {
+ hasLowerLimitPitch = Standard_False;
+ aLowerLimitPitch = 0;
+ }
+
+ Standard_Real aUpperLimitPitch;
+ Standard_Boolean hasUpperLimitPitch = Standard_True;
+ if (theData->IsParamDefined(theNum, 5))
+ {
+ theData->ReadReal(theNum, 5, "upper_limit_pitch", theArch, aUpperLimitPitch);
+ }
+ else
+ {
+ hasUpperLimitPitch = Standard_False;
+ aUpperLimitPitch = 0;
+ }
+
+ Standard_Real aLowerLimitRoll;
+ Standard_Boolean hasLowerLimitRoll = Standard_True;
+ if (theData->IsParamDefined(theNum, 6))
+ {
+ theData->ReadReal(theNum, 6, "lower_limit_roll", theArch, aLowerLimitRoll);
+ }
+ else
+ {
+ hasLowerLimitRoll = Standard_False;
+ aLowerLimitRoll = 0;
+ }
+
+ Standard_Real aUpperLimitRoll;
+ Standard_Boolean hasUpperLimitRoll = Standard_True;
+ if (theData->IsParamDefined(theNum, 7))
+ {
+ theData->ReadReal(theNum, 7, "upper_limit_roll", theArch, aUpperLimitRoll);
+ }
+ else
+ {
+ hasUpperLimitRoll = Standard_False;
+ aUpperLimitRoll = 0;
+ }
+ Handle(StepKinematics_PointOnSurfacePairWithRange) aLocalPair = Handle(StepKinematics_PointOnSurfacePairWithRange)::DownCast(aKinematicPair);
+ // Initialize kinematic_pair
+ aLocalPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aPointOnSurfacePair_PairSurface,
+ aRangeOnPairSurface,
+ hasLowerLimitYaw,
+ aLowerLimitYaw,
+ hasUpperLimitYaw,
+ aUpperLimitYaw,
+ hasLowerLimitPitch,
+ aLowerLimitPitch,
+ hasUpperLimitPitch,
+ aUpperLimitPitch,
+ hasLowerLimitRoll,
+ aLowerLimitRoll,
+ hasUpperLimitRoll,
+ aUpperLimitRoll);
+ }
+ else // StepKinematics_PointOnSurfacePairWithRange hasn't params
+ {
+ aKinematicPair = new StepKinematics_PointOnSurfacePair;
+ Handle(StepKinematics_PointOnSurfacePair) aLocalPair = Handle(StepKinematics_PointOnSurfacePair)::DownCast(aKinematicPair);
+ // Initialize kinematic_pair
+ aLocalPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aPointOnSurfacePair_PairSurface);
+ }
+ }
+ }
+ else if (!strcmp(aPairtype, "PLANAR_CURVE_PAIR"))
+ {
+ // Inherited fields of PlanarCurvePair
+
+ Handle(StepGeom_Curve) aPlanarCurvePair_Curve1;
+ theData->ReadEntity(theNum, 1, "planar_curve_pair.curve1", theArch, STANDARD_TYPE(StepGeom_Curve), aPlanarCurvePair_Curve1);
+
+ Handle(StepGeom_Curve) aPlanarCurvePair_Curve2;
+ theData->ReadEntity(theNum, 2, "planar_curve_pair.curve2", theArch, STANDARD_TYPE(StepGeom_Curve), aPlanarCurvePair_Curve2);
+
+ Standard_Boolean aPlanarCurvePair_Orientation;
+ theData->ReadBoolean(theNum, 3, "planar_curve_pair.orientation", theArch, aPlanarCurvePair_Orientation);
+
+ if (theData->NamedForComplex("PLANAR_CURVE_PAIR_RANGE", "PCPR", num0, theNum, theArch))
+ {
+ if (theData->CheckNbParams(theNum, 2, theArch, "PLANAR_CURVE_PAIR_RANGE"))
+ {
+ // Own fields of PlanarCurvePairRange
+ aKinematicPair = new StepKinematics_PlanarCurvePairRange;
+
+ Handle(StepGeom_TrimmedCurve) aRangeOnCurve1;
+ theData->ReadEntity(theNum, 1, "range_on_curve1", theArch, STANDARD_TYPE(StepGeom_TrimmedCurve), aRangeOnCurve1);
+
+ Handle(StepGeom_TrimmedCurve) aRangeOnCurve2;
+ theData->ReadEntity(theNum, 2, "range_on_curve2", theArch, STANDARD_TYPE(StepGeom_TrimmedCurve), aRangeOnCurve2);
+
+
+ Handle(StepKinematics_PlanarCurvePairRange) aLocalPair = Handle(StepKinematics_PlanarCurvePairRange)::DownCast(aKinematicPair);
+ // Initialize kinematic_pair
+ aLocalPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aPlanarCurvePair_Curve1,
+ aPlanarCurvePair_Curve2,
+ aPlanarCurvePair_Orientation,
+ aRangeOnCurve1,
+ aRangeOnCurve2);
+ }
+ else // StepKinematics_ScrewPairWithRange hasn't params
+ {
+ aKinematicPair = new StepKinematics_PlanarCurvePair;
+ Handle(StepKinematics_PlanarCurvePair) aLocalPair = Handle(StepKinematics_PlanarCurvePair)::DownCast(aKinematicPair);
+ // Initialize kinematic_pair
+ aLocalPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aPlanarCurvePair_Curve1,
+ aPlanarCurvePair_Curve2,
+ aPlanarCurvePair_Orientation);
+ }
+ }
+ }
+ else if (!strcmp(aPairtype, "SURFACE_PAIR"))
+ {
+ // Inherited fields of SurfacePair
+
+ Handle(StepGeom_Surface) aSurfacePair_Surface1;
+ theData->ReadEntity(theNum, 1, "surface_pair.surface1", theArch, STANDARD_TYPE(StepGeom_Surface), aSurfacePair_Surface1);
+
+ Handle(StepGeom_Surface) aSurfacePair_Surface2;
+ theData->ReadEntity(theNum, 2, "surface_pair.surface2", theArch, STANDARD_TYPE(StepGeom_Surface), aSurfacePair_Surface2);
+
+ Standard_Boolean aSurfacePair_Orientation;
+ theData->ReadBoolean(theNum, 3, "surface_pair.orientation", theArch, aSurfacePair_Orientation);
+
+ if (theData->NamedForComplex("SURFACE_PAIR_WITH_RANGE", "SPW1", num0, theNum, theArch))
+ {
+ if (theData->CheckNbParams(theNum, 4, theArch, "SURFACE_PAIR_WITH_RANGE"))
+ {
+ aKinematicPair = new StepKinematics_SurfacePairWithRange;
+ // Own fields of SurfacePairWithRange
+
+ Handle(StepGeom_RectangularTrimmedSurface) aRangeOnSurface1;
+ theData->ReadEntity(theNum, 1, "range_on_surface1", theArch, STANDARD_TYPE(StepGeom_RectangularTrimmedSurface), aRangeOnSurface1);
+
+ Handle(StepGeom_RectangularTrimmedSurface) aRangeOnSurface2;
+ theData->ReadEntity(theNum, 2, "range_on_surface2", theArch, STANDARD_TYPE(StepGeom_RectangularTrimmedSurface), aRangeOnSurface2);
+
+ Standard_Real aLowerLimitActualRotation;
+ Standard_Boolean hasLowerLimitActualRotation = Standard_True;
+ if (theData->IsParamDefined(theNum, 3))
+ {
+ theData->ReadReal(theNum, 3, "lower_limit_actual_rotation", theArch, aLowerLimitActualRotation);
+ }
+ else
+ {
+ hasLowerLimitActualRotation = Standard_False;
+ aLowerLimitActualRotation = 0;
+ }
+
+ Standard_Real aUpperLimitActualRotation;
+ Standard_Boolean hasUpperLimitActualRotation = Standard_True;
+ if (theData->IsParamDefined(theNum, 4))
+ {
+ theData->ReadReal(theNum, 4, "upper_limit_actual_rotation", theArch, aUpperLimitActualRotation);
+ }
+ else
+ {
+ hasUpperLimitActualRotation = Standard_False;
+ aUpperLimitActualRotation = 0;
+ }
+
+ Handle(StepKinematics_SurfacePairWithRange) aLocalPair = Handle(StepKinematics_SurfacePairWithRange)::DownCast(aKinematicPair);
+ // Initialize kinematic_pair
+ aLocalPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aSurfacePair_Surface1,
+ aSurfacePair_Surface2,
+ aSurfacePair_Orientation,
+ aRangeOnSurface1,
+ aRangeOnSurface2,
+ hasLowerLimitActualRotation,
+ aLowerLimitActualRotation,
+ hasUpperLimitActualRotation,
+ aUpperLimitActualRotation);
+ }
+ else // StepKinematics_SurfacePairWithRange hasn't params
+ {
+ aKinematicPair = new StepKinematics_SurfacePair;
+ Handle(StepKinematics_SurfacePair) aLocalPair = Handle(StepKinematics_SurfacePair)::DownCast(aKinematicPair);
+ // Initialize kinematic_pair
+ aLocalPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aSurfacePair_Surface1,
+ aSurfacePair_Surface2,
+ aSurfacePair_Orientation);
+ }
+ }
+ }
+ }
+ theData->NamedForComplex("REPRESENTATION_ITEM", "RPRITM", num0, theNum, theArch);
+
+ // Own fields of representation_item
+ theData->ReadString(theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+ anActuatedKinematicPair->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name, hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint, hasTX, aTX, hasTY, aTY, hasTZ,
+ aTZ, hasRX, aRX, hasRY, aRY, hasRZ, aRZ);
+
+ // Initialize kinematic_pair
+ aKinematicPair->SetName(aRepresentationItem_Name);
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ anActuatedKinematicPair, aKinematicPair);
+}
+
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWActuatedKinPairAndOrderKinPair::WriteStep
+(StepData_StepWriter& theSW,
+ const Handle(StepKinematics_ActuatedKinPairAndOrderKinPair)& theEnt) const
+{
+ // --- Instance of plex componant BoundedCurve ---
+
+ theSW.StartEntity("(ACTUATED_KINEMATIC_PAIR");
+
+ if (theEnt->GetActuatedKinematicPair()->HasTX())
+ {
+ switch (theEnt->GetActuatedKinematicPair()->TX())
+ {
+ case StepKinematics_adBidirectional: theSW.SendEnum(".BIDIRECTIONAL."); break;
+ case StepKinematics_adPositiveOnly: theSW.SendEnum(".POSITIVE_ONLY."); break;
+ case StepKinematics_adNegativeOnly: theSW.SendEnum(".NEGATIVE_ONLY."); break;
+ case StepKinematics_adNotActuated: theSW.SendEnum(".NOT_ACTUATED."); break;
+ }
+ }
+ else theSW.SendUndef();
+
+ if (theEnt->GetActuatedKinematicPair()->HasTY())
+ {
+ switch (theEnt->GetActuatedKinematicPair()->TY())
+ {
+ case StepKinematics_adBidirectional: theSW.SendEnum(".BIDIRECTIONAL."); break;
+ case StepKinematics_adPositiveOnly: theSW.SendEnum(".POSITIVE_ONLY."); break;
+ case StepKinematics_adNegativeOnly: theSW.SendEnum(".NEGATIVE_ONLY."); break;
+ case StepKinematics_adNotActuated: theSW.SendEnum(".NOT_ACTUATED."); break;
+ }
+ }
+ else theSW.SendUndef();
+
+ if (theEnt->GetActuatedKinematicPair()->HasTZ())
+ {
+ switch (theEnt->GetActuatedKinematicPair()->TZ())
+ {
+ case StepKinematics_adBidirectional: theSW.SendEnum(".BIDIRECTIONAL."); break;
+ case StepKinematics_adPositiveOnly: theSW.SendEnum(".POSITIVE_ONLY."); break;
+ case StepKinematics_adNegativeOnly: theSW.SendEnum(".NEGATIVE_ONLY."); break;
+ case StepKinematics_adNotActuated: theSW.SendEnum(".NOT_ACTUATED."); break;
+ }
+ }
+ else theSW.SendUndef();
+
+ if (theEnt->GetActuatedKinematicPair()->HasRX())
+ {
+ switch (theEnt->GetActuatedKinematicPair()->RX())
+ {
+ case StepKinematics_adBidirectional: theSW.SendEnum(".BIDIRECTIONAL."); break;
+ case StepKinematics_adPositiveOnly: theSW.SendEnum(".POSITIVE_ONLY."); break;
+ case StepKinematics_adNegativeOnly: theSW.SendEnum(".NEGATIVE_ONLY."); break;
+ case StepKinematics_adNotActuated: theSW.SendEnum(".NOT_ACTUATED."); break;
+ }
+ }
+ else theSW.SendUndef();
+
+ if (theEnt->GetActuatedKinematicPair()->HasRY())
+ {
+ switch (theEnt->GetActuatedKinematicPair()->RY())
+ {
+ case StepKinematics_adBidirectional: theSW.SendEnum(".BIDIRECTIONAL."); break;
+ case StepKinematics_adPositiveOnly: theSW.SendEnum(".POSITIVE_ONLY."); break;
+ case StepKinematics_adNegativeOnly: theSW.SendEnum(".NEGATIVE_ONLY."); break;
+ case StepKinematics_adNotActuated: theSW.SendEnum(".NOT_ACTUATED."); break;
+ }
+ }
+ else theSW.SendUndef();
+
+ if (theEnt->GetActuatedKinematicPair()->HasRZ())
+ {
+ switch (theEnt->GetActuatedKinematicPair()->RZ())
+ {
+ case StepKinematics_adBidirectional: theSW.SendEnum(".BIDIRECTIONAL."); break;
+ case StepKinematics_adPositiveOnly: theSW.SendEnum(".POSITIVE_ONLY."); break;
+ case StepKinematics_adNegativeOnly: theSW.SendEnum(".NEGATIVE_ONLY."); break;
+ case StepKinematics_adNotActuated: theSW.SendEnum(".NOT_ACTUATED."); break;
+ }
+ }
+ else theSW.SendUndef();
+ theSW.StartEntity("(GEOMETRIC_REPRESENTATION_ITEM");
+
+ theSW.StartEntity("(ITEM_DEFINED_TRANSFORMATION");
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send(theEnt->ItemDefinedTransformation()->Name());
+
+ if (theEnt->ItemDefinedTransformation()->HasDescription())
+ {
+ theSW.Send(theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send(theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send(theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ theSW.StartEntity("(KINEMATIC_PAIR");
+
+ // Own fields of KinematicPair
+
+ theSW.Send(theEnt->Joint());
+ if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_LowOrderKinematicPair)))
+ {
+ Handle(StepKinematics_LowOrderKinematicPair) aLowOrderKinematicPair = Handle(StepKinematics_LowOrderKinematicPair)::DownCast(theEnt->GetOrderKinematicPair());
+ theSW.StartEntity("(LOW_ORDER_KINEMATIC_PAIR");
+
+ theSW.SendBoolean(aLowOrderKinematicPair->TX());
+
+ theSW.SendBoolean(aLowOrderKinematicPair->TY());
+
+ theSW.SendBoolean(aLowOrderKinematicPair->TZ());
+
+ theSW.SendBoolean(aLowOrderKinematicPair->RX());
+
+ theSW.SendBoolean(aLowOrderKinematicPair->RY());
+
+ theSW.SendBoolean(aLowOrderKinematicPair->RZ());
+
+ if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_RevolutePair)))
+ {
+ theSW.StartEntity("(REVOLUTE_PAIR");
+ theSW.StartEntity("(REVOLUTE_PAIR_WITH_RANGE");
+ if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_RevolutePairWithRange)))
+ {
+ Handle(StepKinematics_RevolutePairWithRange) aRevolutePairWithRange = Handle(StepKinematics_RevolutePairWithRange)::DownCast(theEnt->GetOrderKinematicPair());
+ // Own fields of RevolutePairWithRange
+
+ if (aRevolutePairWithRange->HasLowerLimitActualRotation())
+ {
+ theSW.Send(aRevolutePairWithRange->LowerLimitActualRotation());
+ }
+ else theSW.SendUndef();
+
+ if (aRevolutePairWithRange->HasUpperLimitActualRotation())
+ {
+ theSW.Send(aRevolutePairWithRange->UpperLimitActualRotation());
+ }
+ else theSW.SendUndef();
+ }
+ }
+ else if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_CylindricalPair)))
+ {
+ theSW.StartEntity("(CYLINDRICAL_PAIR");
+ theSW.StartEntity("(CYLINDRICAL_PAIR_WITH_RANGE");
+ if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_CylindricalPairWithRange)))
+ {
+ Handle(StepKinematics_CylindricalPairWithRange) aCylindricalPairWithRange = Handle(StepKinematics_CylindricalPairWithRange)::DownCast(theEnt->GetOrderKinematicPair());
+ // Own fields of CylindricalPairWithRange
+
+ if (aCylindricalPairWithRange->HasLowerLimitActualTranslation())
+ {
+ theSW.Send(aCylindricalPairWithRange->LowerLimitActualTranslation());
+ }
+ else theSW.SendUndef();
+
+ if (aCylindricalPairWithRange->HasUpperLimitActualTranslation())
+ {
+ theSW.Send(aCylindricalPairWithRange->UpperLimitActualTranslation());
+ }
+ else theSW.SendUndef();
+
+ if (aCylindricalPairWithRange->HasLowerLimitActualRotation())
+ {
+ theSW.Send(aCylindricalPairWithRange->LowerLimitActualRotation());
+ }
+ else theSW.SendUndef();
+
+ if (aCylindricalPairWithRange->HasUpperLimitActualRotation())
+ {
+ theSW.Send(aCylindricalPairWithRange->UpperLimitActualRotation());
+ }
+ else theSW.SendUndef();
+ }
+ }
+ else if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_SphericalPair)))
+ {
+ theSW.StartEntity("(SPHERICAL_PAIR");
+ theSW.StartEntity("(SPHERICAL_PAIR_WITH_RANGE");
+ if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_SphericalPairWithRange)))
+ {
+ Handle(StepKinematics_SphericalPairWithRange) aSphericalPairWithRange = Handle(StepKinematics_SphericalPairWithRange)::DownCast(theEnt->GetOrderKinematicPair());
+ // Own fields of SphericalPairWithRange
+
+ if (aSphericalPairWithRange->HasLowerLimitYaw())
+ {
+ theSW.Send(aSphericalPairWithRange->LowerLimitYaw());
+ }
+ else theSW.SendUndef();
+
+ if (aSphericalPairWithRange->HasUpperLimitYaw())
+ {
+ theSW.Send(aSphericalPairWithRange->UpperLimitYaw());
+ }
+ else theSW.SendUndef();
+
+ if (aSphericalPairWithRange->HasLowerLimitPitch())
+ {
+ theSW.Send(aSphericalPairWithRange->LowerLimitPitch());
+ }
+ else theSW.SendUndef();
+
+ if (aSphericalPairWithRange->HasUpperLimitPitch())
+ {
+ theSW.Send(aSphericalPairWithRange->UpperLimitPitch());
+ }
+ else theSW.SendUndef();
+
+ if (aSphericalPairWithRange->HasLowerLimitRoll())
+ {
+ theSW.Send(aSphericalPairWithRange->LowerLimitRoll());
+ }
+ else theSW.SendUndef();
+
+ if (aSphericalPairWithRange->HasUpperLimitRoll())
+ {
+ theSW.Send(aSphericalPairWithRange->UpperLimitRoll());
+ }
+ else theSW.SendUndef();
+ }
+ }
+ else if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_SphericalPairWithPin)))
+ {
+ theSW.StartEntity("(SPHERICAL_PAIR_WITH_PIN");
+ theSW.StartEntity("(SPHERICAL_PAIR_WITH_PIN_AND_RANGE");
+ if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_SphericalPairWithPinAndRange)))
+ {
+ Handle(StepKinematics_SphericalPairWithPinAndRange) aSphericalPairWithPinAndRange = Handle(StepKinematics_SphericalPairWithPinAndRange)::DownCast(theEnt->GetOrderKinematicPair());
+ // Own fields of SphericalPairWithPinAndRange
+
+ if (aSphericalPairWithPinAndRange->HasLowerLimitYaw())
+ {
+ theSW.Send(aSphericalPairWithPinAndRange->LowerLimitYaw());
+ }
+ else theSW.SendUndef();
+
+ if (aSphericalPairWithPinAndRange->HasUpperLimitYaw())
+ {
+ theSW.Send(aSphericalPairWithPinAndRange->UpperLimitYaw());
+ }
+ else theSW.SendUndef();
+
+ if (aSphericalPairWithPinAndRange->HasLowerLimitRoll())
+ {
+ theSW.Send(aSphericalPairWithPinAndRange->LowerLimitRoll());
+ }
+ else theSW.SendUndef();
+
+ if (aSphericalPairWithPinAndRange->HasUpperLimitRoll())
+ {
+ theSW.Send(aSphericalPairWithPinAndRange->UpperLimitRoll());
+ }
+ else theSW.SendUndef();
+ }
+ }
+ else if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_PrismaticPair)))
+ {
+ theSW.StartEntity("(PRISMATIC_PAIR");
+ theSW.StartEntity("(PRISMATIC_PAIR_WITH_RANGE");
+ if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_PrismaticPairWithRange)))
+ {
+ Handle(StepKinematics_PrismaticPairWithRange) aPrismaticPairWithRange = Handle(StepKinematics_PrismaticPairWithRange)::DownCast(theEnt->GetOrderKinematicPair());
+ // Own fields of PrismaticPairWithRange
+
+ if (aPrismaticPairWithRange->HasLowerLimitActualTranslation())
+ {
+ theSW.Send(aPrismaticPairWithRange->LowerLimitActualTranslation());
+ }
+ else theSW.SendUndef();
+
+ if (aPrismaticPairWithRange->HasUpperLimitActualTranslation())
+ {
+ theSW.Send(aPrismaticPairWithRange->UpperLimitActualTranslation());
+ }
+ else theSW.SendUndef();
+ }
+ }
+ else if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_UniversalPair)))
+ {
+ theSW.StartEntity("(UNIVERSAL_PAIR");
+ Handle(StepKinematics_UniversalPair) anUniversalPair = Handle(StepKinematics_UniversalPair)::DownCast(theEnt->GetOrderKinematicPair());
+ // Own fields of UniversalPair
+
+ if (anUniversalPair->HasInputSkewAngle())
+ {
+ theSW.Send(anUniversalPair->InputSkewAngle());
+ }
+ else theSW.SendUndef();
+
+ theSW.StartEntity("(PRISMATIC_PAIR_WITH_RANGE");
+ if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_PrismaticPairWithRange)))
+ {
+ Handle(StepKinematics_UniversalPairWithRange) anUniversalPairWithRange = Handle(StepKinematics_UniversalPairWithRange)::DownCast(theEnt->GetOrderKinematicPair());
+ // Own fields of UniversalPairWithRange
+
+ if (anUniversalPairWithRange->HasLowerLimitFirstRotation())
+ {
+ theSW.Send(anUniversalPairWithRange->LowerLimitFirstRotation());
+ }
+ else theSW.SendUndef();
+
+ if (anUniversalPairWithRange->HasUpperLimitFirstRotation())
+ {
+ theSW.Send(anUniversalPairWithRange->UpperLimitFirstRotation());
+ }
+ else theSW.SendUndef();
+
+ if (anUniversalPairWithRange->HasLowerLimitSecondRotation())
+ {
+ theSW.Send(anUniversalPairWithRange->LowerLimitSecondRotation());
+ }
+ else theSW.SendUndef();
+
+ if (anUniversalPairWithRange->HasUpperLimitSecondRotation())
+ {
+ theSW.Send(anUniversalPairWithRange->UpperLimitSecondRotation());
+ }
+ else theSW.SendUndef();
+ }
+ }
+ }
+ else if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_LowOrderKinematicPairWithMotionCoupling)))
+ {
+ if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_GearPair)))
+ {
+ theSW.StartEntity("(GEAR_PAIR");
+ Handle(StepKinematics_GearPair) aGearPair = Handle(StepKinematics_GearPair)::DownCast(theEnt->GetOrderKinematicPair());
+ // Own fields of GearPair
+
+ theSW.Send(aGearPair->RadiusFirstLink());
+
+ theSW.Send(aGearPair->RadiusSecondLink());
+
+ theSW.Send(aGearPair->Bevel());
+
+ theSW.Send(aGearPair->HelicalAngle());
+
+ theSW.Send(aGearPair->GearRatio());
+
+ theSW.StartEntity("(PRISMATIC_PAIR_WITH_RANGE");
+ if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_GearPairWithRange)))
+ {
+ Handle(StepKinematics_GearPairWithRange) aGearPairWithRange = Handle(StepKinematics_GearPairWithRange)::DownCast(theEnt->GetOrderKinematicPair());
+ // Own fields of GearPairWithRange
+
+ if (aGearPairWithRange->HasLowerLimitActualRotation1())
+ {
+ theSW.Send(aGearPairWithRange->LowerLimitActualRotation1());
+ }
+ else theSW.SendUndef();
+
+ if (aGearPairWithRange->HasUpperLimitActualRotation1())
+ {
+ theSW.Send(aGearPairWithRange->UpperLimitActualRotation1());
+ }
+ else theSW.SendUndef();
+ }
+ }
+ else if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_RackAndPinionPair)))
+ {
+ theSW.StartEntity("RACK_AND_PINION_PAIR");
+ Handle(StepKinematics_RackAndPinionPair) aRackAndPinionPair = Handle(StepKinematics_RackAndPinionPair)::DownCast(theEnt->GetOrderKinematicPair());
+ // Own fields of RackAndPinionPair
+
+ theSW.Send(aRackAndPinionPair->PinionRadius());
+
+ theSW.StartEntity("(RACK_AND_PINION_PAIR_WITH_RANGE");
+ if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_RackAndPinionPairWithRange)))
+ {
+ Handle(StepKinematics_RackAndPinionPairWithRange) aRackAndPinionPairWithRange = Handle(StepKinematics_RackAndPinionPairWithRange)::DownCast(theEnt->GetOrderKinematicPair());
+ // Own fields of aRackAndPinionPairWithRange
+
+ if (aRackAndPinionPairWithRange->HasLowerLimitRackDisplacement())
+ {
+ theSW.Send(aRackAndPinionPairWithRange->LowerLimitRackDisplacement());
+ }
+ else theSW.SendUndef();
+
+ if (aRackAndPinionPairWithRange->HasUpperLimitRackDisplacement())
+ {
+ theSW.Send(aRackAndPinionPairWithRange->UpperLimitRackDisplacement());
+ }
+ else theSW.SendUndef();
+ }
+ }
+ else if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_ScrewPair)))
+ {
+ theSW.StartEntity("SCREW_PAIR");
+ Handle(StepKinematics_ScrewPair) aScrewPair = Handle(StepKinematics_ScrewPair)::DownCast(theEnt->GetOrderKinematicPair());
+ // Own fields of ScrewPair
+
+ theSW.Send(aScrewPair->Pitch());
+
+ theSW.StartEntity("(SCREW_PAIR_WITH_RANGE");
+ if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_ScrewPairWithRange)))
+ {
+ Handle(StepKinematics_ScrewPairWithRange) aScrewPairWithRange = Handle(StepKinematics_ScrewPairWithRange)::DownCast(theEnt->GetOrderKinematicPair());
+ // Own fields of aRackAndPinionPairWithRange
+
+ if (aScrewPairWithRange->HasLowerLimitActualRotation())
+ {
+ theSW.Send(aScrewPairWithRange->LowerLimitActualRotation());
+ }
+ else theSW.SendUndef();
+
+ if (aScrewPairWithRange->HasUpperLimitActualRotation())
+ {
+ theSW.Send(aScrewPairWithRange->UpperLimitActualRotation());
+ }
+ else theSW.SendUndef();
+ }
+ }
+ }
+ else if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_HighOrderKinematicPair)))
+ {
+ if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_ScrewPair)))
+ {
+ theSW.StartEntity("POINT_ON_PLANAR_CURVE_PAIR");
+ Handle(StepKinematics_PointOnPlanarCurvePair) aPointOnPlanarCurvePair = Handle(StepKinematics_PointOnPlanarCurvePair)::DownCast(theEnt->GetOrderKinematicPair());
+ // Own fields of PointOnPlanarCurvePair
+
+ theSW.Send(aPointOnPlanarCurvePair->PairCurve());
+
+ theSW.SendBoolean(aPointOnPlanarCurvePair->Orientation());
+
+ theSW.StartEntity("(POINT_ON_PLANAR_CURVE_PAIR_WITH_RANGE");
+ if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_PointOnPlanarCurvePairWithRange)))
+ {
+ Handle(StepKinematics_PointOnPlanarCurvePairWithRange) aPointOnPlanarCurvePairWithRange = Handle(StepKinematics_PointOnPlanarCurvePairWithRange)::DownCast(theEnt->GetOrderKinematicPair());
+ // Own fields of PointOnPlanarCurvePairWithRange
+
+ theSW.Send(aPointOnPlanarCurvePairWithRange->RangeOnPairCurve());
+
+ if (aPointOnPlanarCurvePairWithRange->HasLowerLimitYaw())
+ {
+ theSW.Send(aPointOnPlanarCurvePairWithRange->LowerLimitYaw());
+ }
+ else theSW.SendUndef();
+
+ if (aPointOnPlanarCurvePairWithRange->HasUpperLimitYaw())
+ {
+ theSW.Send(aPointOnPlanarCurvePairWithRange->UpperLimitYaw());
+ }
+ else theSW.SendUndef();
+
+ if (aPointOnPlanarCurvePairWithRange->HasLowerLimitPitch())
+ {
+ theSW.Send(aPointOnPlanarCurvePairWithRange->LowerLimitPitch());
+ }
+ else theSW.SendUndef();
+
+ if (aPointOnPlanarCurvePairWithRange->HasUpperLimitPitch())
+ {
+ theSW.Send(aPointOnPlanarCurvePairWithRange->UpperLimitPitch());
+ }
+ else theSW.SendUndef();
+
+ if (aPointOnPlanarCurvePairWithRange->HasLowerLimitRoll())
+ {
+ theSW.Send(aPointOnPlanarCurvePairWithRange->LowerLimitRoll());
+ }
+ else theSW.SendUndef();
+
+ if (aPointOnPlanarCurvePairWithRange->HasUpperLimitRoll())
+ {
+ theSW.Send(aPointOnPlanarCurvePairWithRange->UpperLimitRoll());
+ }
+ else theSW.SendUndef();
+ }
+ }
+ else if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_PointOnSurfacePair)))
+ {
+ theSW.StartEntity("POINT_ON_SURFACE_PAIR");
+ Handle(StepKinematics_PointOnSurfacePair) aPointOnSurfacePair = Handle(StepKinematics_PointOnSurfacePair)::DownCast(theEnt->GetOrderKinematicPair());
+ // Own fields of PointOnSurfacePair
+
+ theSW.Send(aPointOnSurfacePair->PairSurface());
+
+ theSW.StartEntity("(SCREW_PAIR_WITH_RANGE");
+ if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_PointOnSurfacePairWithRange)))
+ {
+ Handle(StepKinematics_PointOnSurfacePairWithRange) aPointOnSurfacePairWithRange = Handle(StepKinematics_PointOnSurfacePairWithRange)::DownCast(theEnt->GetOrderKinematicPair());
+ // Own fields of PointOnSurfacePairWithRange
+
+ theSW.Send(aPointOnSurfacePairWithRange->RangeOnPairSurface());
+
+ if (aPointOnSurfacePairWithRange->HasLowerLimitYaw())
+ {
+ theSW.Send(aPointOnSurfacePairWithRange->LowerLimitYaw());
+ }
+ else theSW.SendUndef();
+
+ if (aPointOnSurfacePairWithRange->HasUpperLimitYaw())
+ {
+ theSW.Send(aPointOnSurfacePairWithRange->UpperLimitYaw());
+ }
+ else theSW.SendUndef();
+
+ if (aPointOnSurfacePairWithRange->HasLowerLimitPitch())
+ {
+ theSW.Send(aPointOnSurfacePairWithRange->LowerLimitPitch());
+ }
+ else theSW.SendUndef();
+
+ if (aPointOnSurfacePairWithRange->HasUpperLimitPitch())
+ {
+ theSW.Send(aPointOnSurfacePairWithRange->UpperLimitPitch());
+ }
+ else theSW.SendUndef();
+
+ if (aPointOnSurfacePairWithRange->HasLowerLimitRoll())
+ {
+ theSW.Send(aPointOnSurfacePairWithRange->LowerLimitRoll());
+ }
+ else theSW.SendUndef();
+
+ if (aPointOnSurfacePairWithRange->HasUpperLimitRoll())
+ {
+ theSW.Send(aPointOnSurfacePairWithRange->UpperLimitRoll());
+ }
+ else theSW.SendUndef();
+ }
+ }
+ else if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_PlanarCurvePair)))
+ {
+ theSW.StartEntity("PLANAR_CURVE_PAIR");
+ Handle(StepKinematics_PlanarCurvePair) aPlanarCurvePair = Handle(StepKinematics_PlanarCurvePair)::DownCast(theEnt->GetOrderKinematicPair());
+ // Own fields of PlanarCurvePair
+
+ theSW.Send(aPlanarCurvePair->Curve1());
+
+ theSW.Send(aPlanarCurvePair->Curve2());
+
+ theSW.StartEntity("(PLANAR_CURVE_PAIR_RANGE");
+ if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_PlanarCurvePairRange)))
+ {
+ Handle(StepKinematics_PlanarCurvePairRange) aPlanarCurvePairRange = Handle(StepKinematics_PlanarCurvePairRange)::DownCast(theEnt->GetOrderKinematicPair());
+ // Own fields of PlanarCurvePairRange
+
+ theSW.Send(aPlanarCurvePairRange->RangeOnCurve1());
+
+ theSW.Send(aPlanarCurvePairRange->RangeOnCurve2());
+ }
+ }
+ else if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_SurfacePair)))
+ {
+ theSW.StartEntity("SURFACE_PAIR");
+ Handle(StepKinematics_SurfacePair) aSurfacePair = Handle(StepKinematics_SurfacePair)::DownCast(theEnt->GetOrderKinematicPair());
+ // Own fields of SurfacePair
+
+ theSW.Send(aSurfacePair->Surface1());
+
+ theSW.Send(aSurfacePair->Surface2());
+
+ theSW.SendBoolean(aSurfacePair->Orientation());
+
+ theSW.StartEntity("(SURFACE_PAIR_WITH_RANGE");
+ if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_SurfacePairWithRange)))
+ {
+ Handle(StepKinematics_SurfacePairWithRange) aSurfacePairWithRange = Handle(StepKinematics_SurfacePairWithRange)::DownCast(theEnt->GetOrderKinematicPair());
+ // Own fields of SurfacePairWithRange
+
+ theSW.Send(aSurfacePairWithRange->RangeOnSurface1());
+
+ theSW.Send(aSurfacePairWithRange->RangeOnSurface2());
+
+ if (aSurfacePairWithRange->HasLowerLimitActualRotation())
+ {
+ theSW.Send(aSurfacePairWithRange->LowerLimitActualRotation());
+ }
+ else theSW.SendUndef();
+
+ if (aSurfacePairWithRange->HasUpperLimitActualRotation())
+ {
+ theSW.Send(aSurfacePairWithRange->UpperLimitActualRotation());
+ }
+ else theSW.SendUndef();
+ }
+ }
+ }
+
+ // Own fields of RepresentationItem
+ theSW.StartEntity("REPRESENTATION_ITEM");
+ theSW.Send(theEnt->Name());
+}
+
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWActuatedKinPairAndOrderKinPair::Share
+(const Handle(StepKinematics_ActuatedKinPairAndOrderKinPair)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+ iter.AddItem(theEnt->GetOrderKinematicPair());
+ iter.AddItem(theEnt->GetOrderKinematicPair()->Joint());
+ iter.AddItem(theEnt->GetActuatedKinematicPair());
+ iter.AddItem(theEnt->GetOrderKinematicPair()->ItemDefinedTransformation());
+}
--- /dev/null
+// Created on: 2020-05-26
+// Created by: PASUKHIN DMITRY
+// Copyright (c) 2015 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWActuatedKinPairAndOrderKinPair_HeaderFile
+#define _RWStepKinematics_RWActuatedKinPairAndOrderKinPair_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_ActuatedKinPairAndOrderKinPair;
+
+
+//! Read & Write Module for GeoTolAndGeoTolWthMod
+class RWStepKinematics_RWActuatedKinPairAndOrderKinPair
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ Standard_EXPORT RWStepKinematics_RWActuatedKinPairAndOrderKinPair();
+
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_ActuatedKinPairAndOrderKinPair)& theEnt) const;
+
+ Standard_EXPORT void WriteStep (StepData_StepWriter& theSW, const Handle(StepKinematics_ActuatedKinPairAndOrderKinPair)& theEnt) const;
+
+ Standard_EXPORT void Share (const Handle(StepKinematics_ActuatedKinPairAndOrderKinPair)& theEnt, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepDimTol_RWGeoTolAndGeoTolWthMod_HeaderFile
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWActuatedKinematicPair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_ActuatedKinematicPair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepKinematics_ActuatedDirection.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWActuatedKinematicPair
+//purpose :
+//=======================================================================
+RWStepKinematics_RWActuatedKinematicPair::RWStepKinematics_RWActuatedKinematicPair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWActuatedKinematicPair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_ActuatedKinematicPair)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,12,theArch,"actuated_kinematic_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Own fields of ActuatedKinematicPair
+
+ StepKinematics_ActuatedDirection aTX = StepKinematics_adNotActuated;
+ Standard_Boolean hasTX = Standard_True;
+ if ( theData->IsParamDefined (theNum,7) ) {
+ if (theData->ParamType (theNum, 7) == Interface_ParamEnum) {
+ Standard_CString text = theData->ParamCValue(theNum, 7);
+ if (strcmp(text, ".BIDIRECTIONAL.")) aTX = StepKinematics_adBidirectional;
+ else if (strcmp(text, ".POSITIVE_ONLY.")) aTX = StepKinematics_adPositiveOnly;
+ else if (strcmp(text, ".NEGATIVE_ONLY.")) aTX = StepKinematics_adNegativeOnly;
+ else if (strcmp(text, ".NOT_ACTUATED.")) aTX = StepKinematics_adNotActuated;
+ else theArch->AddFail("Parameter #7 (t_x) has not allowed value");
+ }
+ else theArch->AddFail("Parameter #7 (t_x) is not enumeration");
+ }
+ else {
+ hasTX = Standard_False;
+ }
+
+ StepKinematics_ActuatedDirection aTY = StepKinematics_adNotActuated;
+ Standard_Boolean hasTY = Standard_True;
+ if ( theData->IsParamDefined (theNum,8) ) {
+ if (theData->ParamType (theNum, 8) == Interface_ParamEnum) {
+ Standard_CString text = theData->ParamCValue(theNum, 8);
+ if (strcmp(text, ".BIDIRECTIONAL.")) aTY = StepKinematics_adBidirectional;
+ else if (strcmp(text, ".POSITIVE_ONLY.")) aTY = StepKinematics_adPositiveOnly;
+ else if (strcmp(text, ".NEGATIVE_ONLY.")) aTY = StepKinematics_adNegativeOnly;
+ else if (strcmp(text, ".NOT_ACTUATED.")) aTY = StepKinematics_adNotActuated;
+ else theArch->AddFail("Parameter #8 (t_y) has not allowed value");
+ }
+ else theArch->AddFail("Parameter #8 (t_y) is not enumeration");
+ }
+ else {
+ hasTY = Standard_False;
+ }
+
+ StepKinematics_ActuatedDirection aTZ = StepKinematics_adNotActuated;
+ Standard_Boolean hasTZ = Standard_True;
+ if ( theData->IsParamDefined (theNum,9) ) {
+ if (theData->ParamType (theNum, 9) == Interface_ParamEnum) {
+ Standard_CString text = theData->ParamCValue(theNum, 9);
+ if (strcmp(text, ".BIDIRECTIONAL.")) aTZ = StepKinematics_adBidirectional;
+ else if (strcmp(text, ".POSITIVE_ONLY.")) aTZ = StepKinematics_adPositiveOnly;
+ else if (strcmp(text, ".NEGATIVE_ONLY.")) aTZ = StepKinematics_adNegativeOnly;
+ else if (strcmp(text, ".NOT_ACTUATED.")) aTZ = StepKinematics_adNotActuated;
+ else theArch->AddFail("Parameter #9 (t_z) has not allowed value");
+ }
+ else theArch->AddFail("Parameter #9 (t_z) is not enumeration");
+ }
+ else {
+ hasTZ = Standard_False;
+ }
+
+ StepKinematics_ActuatedDirection aRX = StepKinematics_adNotActuated;
+ Standard_Boolean hasRX = Standard_True;
+ if ( theData->IsParamDefined (theNum,10) ) {
+ if (theData->ParamType (theNum, 10) == Interface_ParamEnum) {
+ Standard_CString text = theData->ParamCValue(theNum, 10);
+ if (strcmp(text, ".BIDIRECTIONAL.")) aRX = StepKinematics_adBidirectional;
+ else if (strcmp(text, ".POSITIVE_ONLY.")) aRX = StepKinematics_adPositiveOnly;
+ else if (strcmp(text, ".NEGATIVE_ONLY.")) aRX = StepKinematics_adNegativeOnly;
+ else if (strcmp(text, ".NOT_ACTUATED.")) aRX = StepKinematics_adNotActuated;
+ else theArch->AddFail("Parameter #10 (r_x) has not allowed value");
+ }
+ else theArch->AddFail("Parameter #10 (r_x) is not enumeration");
+ }
+ else {
+ hasRX = Standard_False;
+ }
+
+ StepKinematics_ActuatedDirection aRY = StepKinematics_adNotActuated;
+ Standard_Boolean hasRY = Standard_True;
+ if ( theData->IsParamDefined (theNum,11) ) {
+ if (theData->ParamType (theNum, 11) == Interface_ParamEnum) {
+ Standard_CString text = theData->ParamCValue(theNum, 11);
+ if (strcmp(text, ".BIDIRECTIONAL.")) aRY = StepKinematics_adBidirectional;
+ else if (strcmp(text, ".POSITIVE_ONLY.")) aRY = StepKinematics_adPositiveOnly;
+ else if (strcmp(text, ".NEGATIVE_ONLY.")) aRY = StepKinematics_adNegativeOnly;
+ else if (strcmp(text, ".NOT_ACTUATED.")) aRY = StepKinematics_adNotActuated;
+ else theArch->AddFail("Parameter #11 (r_y) has not allowed value");
+ }
+ else theArch->AddFail("Parameter #11 (r_y) is not enumeration");
+ }
+ else {
+ hasRY = Standard_False;
+ }
+
+ StepKinematics_ActuatedDirection aRZ = StepKinematics_adNotActuated;
+ Standard_Boolean hasRZ = Standard_True;
+ if ( theData->IsParamDefined (theNum,12) ) {
+ if (theData->ParamType (theNum, 12) == Interface_ParamEnum) {
+ Standard_CString text = theData->ParamCValue(theNum, 12);
+ if (strcmp(text, ".BIDIRECTIONAL.")) aRZ = StepKinematics_adBidirectional;
+ else if (strcmp(text, ".POSITIVE_ONLY.")) aRZ = StepKinematics_adPositiveOnly;
+ else if (strcmp(text, ".NEGATIVE_ONLY.")) aRZ = StepKinematics_adNegativeOnly;
+ else if (strcmp(text, ".NOT_ACTUATED.")) aRZ = StepKinematics_adNotActuated;
+ else theArch->AddFail("Parameter #12 (r_z) has not allowed value");
+ }
+ else theArch->AddFail("Parameter #12 (r_z) is not enumeration");
+ }
+ else {
+ hasRZ = Standard_False;
+ }
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ hasTX,
+ aTX,
+ hasTY,
+ aTY,
+ hasTZ,
+ aTZ,
+ hasRX,
+ aRX,
+ hasRY,
+ aRY,
+ hasRZ,
+ aRZ);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWActuatedKinematicPair::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_ActuatedKinematicPair)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of ActuatedKinematicPair
+
+ if ( theEnt->HasTX() ) {
+ switch (theEnt->TX()) {
+ case StepKinematics_adBidirectional: theSW.SendEnum (".BIDIRECTIONAL."); break;
+ case StepKinematics_adPositiveOnly: theSW.SendEnum (".POSITIVE_ONLY."); break;
+ case StepKinematics_adNegativeOnly: theSW.SendEnum (".NEGATIVE_ONLY."); break;
+ case StepKinematics_adNotActuated: theSW.SendEnum (".NOT_ACTUATED."); break;
+ }
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasTY() ) {
+ switch (theEnt->TY()) {
+ case StepKinematics_adBidirectional: theSW.SendEnum (".BIDIRECTIONAL."); break;
+ case StepKinematics_adPositiveOnly: theSW.SendEnum (".POSITIVE_ONLY."); break;
+ case StepKinematics_adNegativeOnly: theSW.SendEnum (".NEGATIVE_ONLY."); break;
+ case StepKinematics_adNotActuated: theSW.SendEnum (".NOT_ACTUATED."); break;
+ }
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasTZ() ) {
+ switch (theEnt->TZ()) {
+ case StepKinematics_adBidirectional: theSW.SendEnum (".BIDIRECTIONAL."); break;
+ case StepKinematics_adPositiveOnly: theSW.SendEnum (".POSITIVE_ONLY."); break;
+ case StepKinematics_adNegativeOnly: theSW.SendEnum (".NEGATIVE_ONLY."); break;
+ case StepKinematics_adNotActuated: theSW.SendEnum (".NOT_ACTUATED."); break;
+ }
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasRX() ) {
+ switch (theEnt->RX()) {
+ case StepKinematics_adBidirectional: theSW.SendEnum (".BIDIRECTIONAL."); break;
+ case StepKinematics_adPositiveOnly: theSW.SendEnum (".POSITIVE_ONLY."); break;
+ case StepKinematics_adNegativeOnly: theSW.SendEnum (".NEGATIVE_ONLY."); break;
+ case StepKinematics_adNotActuated: theSW.SendEnum (".NOT_ACTUATED."); break;
+ }
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasRY() ) {
+ switch (theEnt->RY()) {
+ case StepKinematics_adBidirectional: theSW.SendEnum (".BIDIRECTIONAL."); break;
+ case StepKinematics_adPositiveOnly: theSW.SendEnum (".POSITIVE_ONLY."); break;
+ case StepKinematics_adNegativeOnly: theSW.SendEnum (".NEGATIVE_ONLY."); break;
+ case StepKinematics_adNotActuated: theSW.SendEnum (".NOT_ACTUATED."); break;
+ }
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasRZ() ) {
+ switch (theEnt->RZ()) {
+ case StepKinematics_adBidirectional: theSW.SendEnum (".BIDIRECTIONAL."); break;
+ case StepKinematics_adPositiveOnly: theSW.SendEnum (".POSITIVE_ONLY."); break;
+ case StepKinematics_adNegativeOnly: theSW.SendEnum (".NEGATIVE_ONLY."); break;
+ case StepKinematics_adNotActuated: theSW.SendEnum (".NOT_ACTUATED."); break;
+ }
+ }
+ else theSW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWActuatedKinematicPair::Share (const Handle(StepKinematics_ActuatedKinematicPair)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Own fields of ActuatedKinematicPair
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWActuatedKinematicPair_HeaderFile_
+#define _RWStepKinematics_RWActuatedKinematicPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_ActuatedKinematicPair;
+
+//! Read & Write tool for ActuatedKinematicPair
+class RWStepKinematics_RWActuatedKinematicPair
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWActuatedKinematicPair();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_ActuatedKinematicPair)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_ActuatedKinematicPair)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_ActuatedKinematicPair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWActuatedKinematicPair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWContextDependentKinematicLinkRepresentation.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_ContextDependentKinematicLinkRepresentation.hxx>
+#include <StepKinematics_KinematicLinkRepresentationAssociation.hxx>
+#include <StepKinematics_ProductDefinitionRelationshipKinematics.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWContextDependentKinematicLinkRepresentation
+//purpose :
+//=======================================================================
+RWStepKinematics_RWContextDependentKinematicLinkRepresentation::RWStepKinematics_RWContextDependentKinematicLinkRepresentation() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWContextDependentKinematicLinkRepresentation::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_ContextDependentKinematicLinkRepresentation)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,2,theArch,"context_dependent_kinematic_link_representation") ) return;
+
+ // Own fields of ContextDependentKinematicLinkRepresentation
+
+ Handle(StepKinematics_KinematicLinkRepresentationAssociation) aRepresentationRelation;
+ theData->ReadEntity (theNum, 1, "representation_relation", theArch, STANDARD_TYPE(StepKinematics_KinematicLinkRepresentationAssociation), aRepresentationRelation);
+
+ Handle(StepKinematics_ProductDefinitionRelationshipKinematics) aRepresentedProductRelation;
+ theData->ReadEntity (theNum, 2, "represented_product_relation", theArch, STANDARD_TYPE(StepKinematics_ProductDefinitionRelationshipKinematics), aRepresentedProductRelation);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationRelation,
+ aRepresentedProductRelation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWContextDependentKinematicLinkRepresentation::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_ContextDependentKinematicLinkRepresentation)& theEnt) const
+{
+
+ // Own fields of ContextDependentKinematicLinkRepresentation
+
+ theSW.Send (theEnt->RepresentationRelation());
+
+ theSW.Send (theEnt->RepresentedProductRelation());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWContextDependentKinematicLinkRepresentation::Share (const Handle(StepKinematics_ContextDependentKinematicLinkRepresentation)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Own fields of ContextDependentKinematicLinkRepresentation
+
+ iter.AddItem (theEnt->RepresentationRelation());
+
+ iter.AddItem (theEnt->RepresentedProductRelation());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWContextDependentKinematicLinkRepresentation_HeaderFile_
+#define _RWStepKinematics_RWContextDependentKinematicLinkRepresentation_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_ContextDependentKinematicLinkRepresentation;
+
+//! Read & Write tool for ContextDependentKinematicLinkRepresentation
+class RWStepKinematics_RWContextDependentKinematicLinkRepresentation
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWContextDependentKinematicLinkRepresentation();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_ContextDependentKinematicLinkRepresentation)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_ContextDependentKinematicLinkRepresentation)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_ContextDependentKinematicLinkRepresentation)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWContextDependentKinematicLinkRepresentation_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWCylindricalPair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_CylindricalPair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWCylindricalPair
+//purpose :
+//=======================================================================
+RWStepKinematics_RWCylindricalPair::RWStepKinematics_RWCylindricalPair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWCylindricalPair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_CylindricalPair)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,12,theArch,"cylindrical_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWCylindricalPair::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_CylindricalPair)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ theSW.SendBoolean (theEnt->TX());
+
+ theSW.SendBoolean (theEnt->TY());
+
+ theSW.SendBoolean (theEnt->TZ());
+
+ theSW.SendBoolean (theEnt->RX());
+
+ theSW.SendBoolean (theEnt->RY());
+
+ theSW.SendBoolean (theEnt->RZ());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWCylindricalPair::Share (const Handle(StepKinematics_CylindricalPair)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWCylindricalPair_HeaderFile_
+#define _RWStepKinematics_RWCylindricalPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_CylindricalPair;
+
+//! Read & Write tool for CylindricalPair
+class RWStepKinematics_RWCylindricalPair
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWCylindricalPair();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_CylindricalPair)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_CylindricalPair)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_CylindricalPair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWCylindricalPair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWCylindricalPairValue.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_CylindricalPairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWCylindricalPairValue
+//purpose :
+//=======================================================================
+RWStepKinematics_RWCylindricalPairValue::RWStepKinematics_RWCylindricalPairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWCylindricalPairValue::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_CylindricalPairValue)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,4,theArch,"cylindrical_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Own fields of CylindricalPairValue
+
+ Standard_Real aActualTranslation;
+ theData->ReadReal (theNum, 3, "actual_translation", theArch, aActualTranslation);
+
+ Standard_Real aActualRotation;
+ theData->ReadReal (theNum, 4, "actual_rotation", theArch, aActualRotation);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair,
+ aActualTranslation,
+ aActualRotation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWCylindricalPairValue::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_CylindricalPairValue)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Own fields of PairValue
+
+ theSW.Send (theEnt->AppliesToPair());
+
+ // Own fields of CylindricalPairValue
+
+ theSW.Send (theEnt->ActualTranslation());
+
+ theSW.Send (theEnt->ActualRotation());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWCylindricalPairValue::Share (const Handle(StepKinematics_CylindricalPairValue)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair());
+
+ // Own fields of CylindricalPairValue
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWCylindricalPairValue_HeaderFile_
+#define _RWStepKinematics_RWCylindricalPairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_CylindricalPairValue;
+
+//! Read & Write tool for CylindricalPairValue
+class RWStepKinematics_RWCylindricalPairValue
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWCylindricalPairValue();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_CylindricalPairValue)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_CylindricalPairValue)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_CylindricalPairValue)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWCylindricalPairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWCylindricalPairWithRange.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_CylindricalPairWithRange.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWCylindricalPairWithRange
+//purpose :
+//=======================================================================
+RWStepKinematics_RWCylindricalPairWithRange::RWStepKinematics_RWCylindricalPairWithRange() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWCylindricalPairWithRange::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_CylindricalPairWithRange)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,16,theArch,"cylindrical_pair_with_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ);
+
+ // Own fields of CylindricalPairWithRange
+
+ Standard_Real aLowerLimitActualTranslation;
+ Standard_Boolean hasLowerLimitActualTranslation = Standard_True;
+ if ( theData->IsParamDefined (theNum,13) ) {
+ theData->ReadReal (theNum, 13, "lower_limit_actual_translation", theArch, aLowerLimitActualTranslation);
+ }
+ else {
+ hasLowerLimitActualTranslation = Standard_False;
+ aLowerLimitActualTranslation = 0;
+ }
+
+ Standard_Real aUpperLimitActualTranslation;
+ Standard_Boolean hasUpperLimitActualTranslation = Standard_True;
+ if ( theData->IsParamDefined (theNum,14) ) {
+ theData->ReadReal (theNum, 14, "upper_limit_actual_translation", theArch, aUpperLimitActualTranslation);
+ }
+ else {
+ hasUpperLimitActualTranslation = Standard_False;
+ aUpperLimitActualTranslation = 0;
+ }
+
+ Standard_Real aLowerLimitActualRotation;
+ Standard_Boolean hasLowerLimitActualRotation = Standard_True;
+ if ( theData->IsParamDefined (theNum,15) ) {
+ theData->ReadReal (theNum, 15, "lower_limit_actual_rotation", theArch, aLowerLimitActualRotation);
+ }
+ else {
+ hasLowerLimitActualRotation = Standard_False;
+ aLowerLimitActualRotation = 0;
+ }
+
+ Standard_Real aUpperLimitActualRotation;
+ Standard_Boolean hasUpperLimitActualRotation = Standard_True;
+ if ( theData->IsParamDefined (theNum,16) ) {
+ theData->ReadReal (theNum, 16, "upper_limit_actual_rotation", theArch, aUpperLimitActualRotation);
+ }
+ else {
+ hasUpperLimitActualRotation = Standard_False;
+ aUpperLimitActualRotation = 0;
+ }
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ,
+ hasLowerLimitActualTranslation,
+ aLowerLimitActualTranslation,
+ hasUpperLimitActualTranslation,
+ aUpperLimitActualTranslation,
+ hasLowerLimitActualRotation,
+ aLowerLimitActualRotation,
+ hasUpperLimitActualRotation,
+ aUpperLimitActualRotation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWCylindricalPairWithRange::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_CylindricalPairWithRange)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ theSW.SendBoolean (theEnt->TX());
+
+ theSW.SendBoolean (theEnt->TY());
+
+ theSW.SendBoolean (theEnt->TZ());
+
+ theSW.SendBoolean (theEnt->RX());
+
+ theSW.SendBoolean (theEnt->RY());
+
+ theSW.SendBoolean (theEnt->RZ());
+
+ // Own fields of CylindricalPairWithRange
+
+ if ( theEnt->HasLowerLimitActualTranslation() ) {
+ theSW.Send (theEnt->LowerLimitActualTranslation());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitActualTranslation() ) {
+ theSW.Send (theEnt->UpperLimitActualTranslation());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasLowerLimitActualRotation() ) {
+ theSW.Send (theEnt->LowerLimitActualRotation());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitActualRotation() ) {
+ theSW.Send (theEnt->UpperLimitActualRotation());
+ }
+ else theSW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWCylindricalPairWithRange::Share (const Handle(StepKinematics_CylindricalPairWithRange)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+
+ // Own fields of CylindricalPairWithRange
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWCylindricalPairWithRange_HeaderFile_
+#define _RWStepKinematics_RWCylindricalPairWithRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_CylindricalPairWithRange;
+
+//! Read & Write tool for CylindricalPairWithRange
+class RWStepKinematics_RWCylindricalPairWithRange
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWCylindricalPairWithRange();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_CylindricalPairWithRange)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_CylindricalPairWithRange)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_CylindricalPairWithRange)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWCylindricalPairWithRange_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWFullyConstrainedPair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_FullyConstrainedPair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWFullyConstrainedPair
+//purpose :
+//=======================================================================
+RWStepKinematics_RWFullyConstrainedPair::RWStepKinematics_RWFullyConstrainedPair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWFullyConstrainedPair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_FullyConstrainedPair)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,12,theArch,"fully_constrained_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWFullyConstrainedPair::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_FullyConstrainedPair)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ theSW.SendBoolean (theEnt->TX());
+
+ theSW.SendBoolean (theEnt->TY());
+
+ theSW.SendBoolean (theEnt->TZ());
+
+ theSW.SendBoolean (theEnt->RX());
+
+ theSW.SendBoolean (theEnt->RY());
+
+ theSW.SendBoolean (theEnt->RZ());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWFullyConstrainedPair::Share (const Handle(StepKinematics_FullyConstrainedPair)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWFullyConstrainedPair_HeaderFile_
+#define _RWStepKinematics_RWFullyConstrainedPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_FullyConstrainedPair;
+
+//! Read & Write tool for FullyConstrainedPair
+class RWStepKinematics_RWFullyConstrainedPair
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWFullyConstrainedPair();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_FullyConstrainedPair)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_FullyConstrainedPair)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_FullyConstrainedPair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWFullyConstrainedPair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWGearPair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_GearPair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWGearPair
+//purpose :
+//=======================================================================
+RWStepKinematics_RWGearPair::RWStepKinematics_RWGearPair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWGearPair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_GearPair)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,11,theArch,"gear_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Own fields of GearPair
+
+ Standard_Real aRadiusFirstLink;
+ theData->ReadReal (theNum, 7, "radius_first_link", theArch, aRadiusFirstLink);
+
+ Standard_Real aRadiusSecondLink;
+ theData->ReadReal (theNum, 8, "radius_second_link", theArch, aRadiusSecondLink);
+
+ Standard_Real aBevel;
+ theData->ReadReal (theNum, 9, "bevel", theArch, aBevel);
+
+ Standard_Real aHelicalAngle;
+ theData->ReadReal (theNum, 10, "helical_angle", theArch, aHelicalAngle);
+
+ Standard_Real aGearRatio;
+ theData->ReadReal (theNum, 11, "gear_ratio", theArch, aGearRatio);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aRadiusFirstLink,
+ aRadiusSecondLink,
+ aBevel,
+ aHelicalAngle,
+ aGearRatio);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWGearPair::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_GearPair)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of GearPair
+
+ theSW.Send (theEnt->RadiusFirstLink());
+
+ theSW.Send (theEnt->RadiusSecondLink());
+
+ theSW.Send (theEnt->Bevel());
+
+ theSW.Send (theEnt->HelicalAngle());
+
+ theSW.Send (theEnt->GearRatio());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWGearPair::Share (const Handle(StepKinematics_GearPair)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Own fields of GearPair
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWGearPair_HeaderFile_
+#define _RWStepKinematics_RWGearPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_GearPair;
+
+//! Read & Write tool for GearPair
+class RWStepKinematics_RWGearPair
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWGearPair();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_GearPair)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_GearPair)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_GearPair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWGearPair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWGearPairValue.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_GearPairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWGearPairValue
+//purpose :
+//=======================================================================
+RWStepKinematics_RWGearPairValue::RWStepKinematics_RWGearPairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWGearPairValue::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_GearPairValue)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,3,theArch,"gear_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Own fields of GearPairValue
+
+ Standard_Real aActualRotation1;
+ theData->ReadReal (theNum, 3, "actual_rotation1", theArch, aActualRotation1);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair,
+ aActualRotation1);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWGearPairValue::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_GearPairValue)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Own fields of PairValue
+
+ theSW.Send (theEnt->AppliesToPair());
+
+ // Own fields of GearPairValue
+
+ theSW.Send (theEnt->ActualRotation1());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWGearPairValue::Share (const Handle(StepKinematics_GearPairValue)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair());
+
+ // Own fields of GearPairValue
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWGearPairValue_HeaderFile_
+#define _RWStepKinematics_RWGearPairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_GearPairValue;
+
+//! Read & Write tool for GearPairValue
+class RWStepKinematics_RWGearPairValue
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWGearPairValue();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_GearPairValue)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_GearPairValue)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_GearPairValue)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWGearPairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWGearPairWithRange.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_GearPairWithRange.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWGearPairWithRange
+//purpose :
+//=======================================================================
+RWStepKinematics_RWGearPairWithRange::RWStepKinematics_RWGearPairWithRange() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWGearPairWithRange::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_GearPairWithRange)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,13,theArch,"gear_pair_with_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of GearPair
+
+ Standard_Real aGearPair_RadiusFirstLink;
+ theData->ReadReal (theNum, 7, "gear_pair.radius_first_link", theArch, aGearPair_RadiusFirstLink);
+
+ Standard_Real aGearPair_RadiusSecondLink;
+ theData->ReadReal (theNum, 8, "gear_pair.radius_second_link", theArch, aGearPair_RadiusSecondLink);
+
+ Standard_Real aGearPair_Bevel;
+ theData->ReadReal (theNum, 9, "gear_pair.bevel", theArch, aGearPair_Bevel);
+
+ Standard_Real aGearPair_HelicalAngle;
+ theData->ReadReal (theNum, 10, "gear_pair.helical_angle", theArch, aGearPair_HelicalAngle);
+
+ Standard_Real aGearPair_GearRatio;
+ theData->ReadReal (theNum, 11, "gear_pair.gear_ratio", theArch, aGearPair_GearRatio);
+
+ // Own fields of GearPairWithRange
+
+ Standard_Real aLowerLimitActualRotation1;
+ Standard_Boolean hasLowerLimitActualRotation1 = Standard_True;
+ if ( theData->IsParamDefined (theNum,12) ) {
+ theData->ReadReal (theNum, 12, "lower_limit_actual_rotation1", theArch, aLowerLimitActualRotation1);
+ }
+ else {
+ hasLowerLimitActualRotation1 = Standard_False;
+ aLowerLimitActualRotation1 = 0;
+ }
+
+ Standard_Real aUpperLimitActualRotation1;
+ Standard_Boolean hasUpperLimitActualRotation1 = Standard_True;
+ if ( theData->IsParamDefined (theNum,13) ) {
+ theData->ReadReal (theNum, 13, "upper_limit_actual_rotation1", theArch, aUpperLimitActualRotation1);
+ }
+ else {
+ hasUpperLimitActualRotation1 = Standard_False;
+ aUpperLimitActualRotation1 = 0;
+ }
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aGearPair_RadiusFirstLink,
+ aGearPair_RadiusSecondLink,
+ aGearPair_Bevel,
+ aGearPair_HelicalAngle,
+ aGearPair_GearRatio,
+ hasLowerLimitActualRotation1,
+ aLowerLimitActualRotation1,
+ hasUpperLimitActualRotation1,
+ aUpperLimitActualRotation1);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWGearPairWithRange::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_GearPairWithRange)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of GearPair
+
+ theSW.Send (theEnt->RadiusFirstLink());
+
+ theSW.Send (theEnt->RadiusSecondLink());
+
+ theSW.Send (theEnt->Bevel());
+
+ theSW.Send (theEnt->HelicalAngle());
+
+ theSW.Send (theEnt->GearRatio());
+
+ // Own fields of GearPairWithRange
+
+ if ( theEnt->HasLowerLimitActualRotation1() ) {
+ theSW.Send (theEnt->LowerLimitActualRotation1());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitActualRotation1() ) {
+ theSW.Send (theEnt->UpperLimitActualRotation1());
+ }
+ else theSW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWGearPairWithRange::Share (const Handle(StepKinematics_GearPairWithRange)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of GearPair
+
+ // Own fields of GearPairWithRange
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWGearPairWithRange_HeaderFile_
+#define _RWStepKinematics_RWGearPairWithRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_GearPairWithRange;
+
+//! Read & Write tool for GearPairWithRange
+class RWStepKinematics_RWGearPairWithRange
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWGearPairWithRange();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_GearPairWithRange)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_GearPairWithRange)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_GearPairWithRange)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWGearPairWithRange_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWHomokineticPair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_HomokineticPair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWHomokineticPair
+//purpose :
+//=======================================================================
+RWStepKinematics_RWHomokineticPair::RWStepKinematics_RWHomokineticPair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWHomokineticPair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_HomokineticPair)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,13,theArch,"homokinetic_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ);
+
+ // Inherited fields of UniversalPair
+
+ Standard_Real aUniversalPair_InputSkewAngle;
+ Standard_Boolean hasUniversalPair_InputSkewAngle = Standard_True;
+ if ( theData->IsParamDefined (theNum,13) ) {
+ theData->ReadReal (theNum, 13, "universal_pair.input_skew_angle", theArch, aUniversalPair_InputSkewAngle);
+ }
+ else {
+ hasUniversalPair_InputSkewAngle = Standard_False;
+ aUniversalPair_InputSkewAngle = 0;
+ }
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ,
+ hasUniversalPair_InputSkewAngle,
+ aUniversalPair_InputSkewAngle);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWHomokineticPair::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_HomokineticPair)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ theSW.SendBoolean (theEnt->TX());
+
+ theSW.SendBoolean (theEnt->TY());
+
+ theSW.SendBoolean (theEnt->TZ());
+
+ theSW.SendBoolean (theEnt->RX());
+
+ theSW.SendBoolean (theEnt->RY());
+
+ theSW.SendBoolean (theEnt->RZ());
+
+ // Own fields of UniversalPair
+
+ if ( theEnt->HasInputSkewAngle() ) {
+ theSW.Send (theEnt->InputSkewAngle());
+ }
+ else theSW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWHomokineticPair::Share (const Handle(StepKinematics_HomokineticPair)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+
+ // Inherited fields of UniversalPair
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWHomokineticPair_HeaderFile_
+#define _RWStepKinematics_RWHomokineticPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_HomokineticPair;
+
+//! Read & Write tool for HomokineticPair
+class RWStepKinematics_RWHomokineticPair
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWHomokineticPair();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_HomokineticPair)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_HomokineticPair)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_HomokineticPair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWHomokineticPair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWKinematicJoint.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepShape_Vertex.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWKinematicJoint
+//purpose :
+//=======================================================================
+RWStepKinematics_RWKinematicJoint::RWStepKinematics_RWKinematicJoint() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWKinematicJoint::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_KinematicJoint)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,3,theArch,"kinematic_joint") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of Edge
+
+ Handle(StepShape_Vertex) aEdge_EdgeStart;
+ theData->ReadEntity (theNum, 2, "edge.edge_start", theArch, STANDARD_TYPE(StepShape_Vertex), aEdge_EdgeStart);
+
+ Handle(StepShape_Vertex) aEdge_EdgeEnd;
+ theData->ReadEntity (theNum, 3, "edge.edge_end", theArch, STANDARD_TYPE(StepShape_Vertex), aEdge_EdgeEnd);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aEdge_EdgeStart,
+ aEdge_EdgeEnd);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWKinematicJoint::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_KinematicJoint)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Own fields of Edge
+
+ theSW.Send (theEnt->EdgeStart());
+
+ theSW.Send (theEnt->EdgeEnd());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWKinematicJoint::Share (const Handle(StepKinematics_KinematicJoint)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of Edge
+
+ iter.AddItem (theEnt->StepShape_Edge::EdgeStart());
+
+ iter.AddItem (theEnt->StepShape_Edge::EdgeEnd());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWKinematicJoint_HeaderFile_
+#define _RWStepKinematics_RWKinematicJoint_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_KinematicJoint;
+
+//! Read & Write tool for KinematicJoint
+class RWStepKinematics_RWKinematicJoint
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWKinematicJoint();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_KinematicJoint)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_KinematicJoint)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_KinematicJoint)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWKinematicJoint_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWKinematicLink.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_KinematicLink.hxx>
+#include <TCollection_HAsciiString.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWKinematicLink
+//purpose :
+//=======================================================================
+RWStepKinematics_RWKinematicLink::RWStepKinematics_RWKinematicLink() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWKinematicLink::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_KinematicLink)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,1,theArch,"kinematic_link") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWKinematicLink::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_KinematicLink)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWKinematicLink::Share (const Handle(StepKinematics_KinematicLink)& /*theEnt*/,
+ Interface_EntityIterator& /*iter*/) const
+{
+
+ // Inherited fields of RepresentationItem
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWKinematicLink_HeaderFile_
+#define _RWStepKinematics_RWKinematicLink_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_KinematicLink;
+
+//! Read & Write tool for KinematicLink
+class RWStepKinematics_RWKinematicLink
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWKinematicLink();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_KinematicLink)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_KinematicLink)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_KinematicLink)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWKinematicLink_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWKinematicLinkRepresentationAssociation.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_KinematicLinkRepresentationAssociation.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_Representation.hxx>
+#include <StepRepr_RepresentationOrRepresentationReference.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWKinematicLinkRepresentationAssociation
+//purpose :
+//=======================================================================
+RWStepKinematics_RWKinematicLinkRepresentationAssociation::RWStepKinematics_RWKinematicLinkRepresentationAssociation() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWKinematicLinkRepresentationAssociation::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_KinematicLinkRepresentationAssociation)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,4,theArch,"kinematic_link_representation_association") ) return;
+
+ // Inherited fields of RepresentationRelationship
+
+ Handle(TCollection_HAsciiString) aRepresentationRelationship_Name;
+ theData->ReadString (theNum, 1, "representation_relationship.name", theArch, aRepresentationRelationship_Name);
+
+ Handle(TCollection_HAsciiString) aRepresentationRelationship_Description;
+ if ( theData->IsParamDefined (theNum,2) ) {
+ theData->ReadString (theNum, 2, "representation_relationship.description", theArch, aRepresentationRelationship_Description);
+ }
+ else {
+ aRepresentationRelationship_Description.Nullify();
+ }
+
+ StepRepr_RepresentationOrRepresentationReference aRepresentationRelationship_Rep1;
+ theData->ReadEntity (theNum, 3, "representation_relationship.rep1", theArch, aRepresentationRelationship_Rep1);
+
+ StepRepr_RepresentationOrRepresentationReference aRepresentationRelationship_Rep2;
+ theData->ReadEntity (theNum, 4, "representation_relationship.rep2", theArch, aRepresentationRelationship_Rep2);
+
+ // Process only one type (Representaion)
+ if (aRepresentationRelationship_Rep1.CaseNumber() != 1 || aRepresentationRelationship_Rep1.CaseNumber() != 1)
+ return;
+
+ // Initialize entity
+ theEnt->Init(aRepresentationRelationship_Name,
+ aRepresentationRelationship_Description,
+ aRepresentationRelationship_Rep1.Representation(),
+ aRepresentationRelationship_Rep2.Representation());
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWKinematicLinkRepresentationAssociation::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_KinematicLinkRepresentationAssociation)& theEnt) const
+{
+
+ // Own fields of RepresentationRelationship
+
+ theSW.Send (theEnt->Name());
+
+ if ( theEnt->HasDescription() ) {
+ theSW.Send (theEnt->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->Rep1());
+
+ theSW.Send (theEnt->Rep2());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWKinematicLinkRepresentationAssociation::Share (const Handle(StepKinematics_KinematicLinkRepresentationAssociation)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationRelationship
+
+ iter.AddItem (theEnt->StepRepr_RepresentationRelationship::Rep1());
+
+ iter.AddItem (theEnt->StepRepr_RepresentationRelationship::Rep2());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWKinematicLinkRepresentationAssociation_HeaderFile_
+#define _RWStepKinematics_RWKinematicLinkRepresentationAssociation_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_KinematicLinkRepresentationAssociation;
+
+//! Read & Write tool for KinematicLinkRepresentationAssociation
+class RWStepKinematics_RWKinematicLinkRepresentationAssociation
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWKinematicLinkRepresentationAssociation();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_KinematicLinkRepresentationAssociation)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_KinematicLinkRepresentationAssociation)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_KinematicLinkRepresentationAssociation)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWKinematicLinkRepresentationAssociation_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWKinematicPropertyMechanismRepresentation.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_KinematicPropertyMechanismRepresentation.hxx>
+#include <StepRepr_RepresentedDefinition.hxx>
+#include <StepRepr_Representation.hxx>
+#include <StepKinematics_KinematicLinkRepresentation.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWKinematicPropertyMechanismRepresentation
+//purpose :
+//=======================================================================
+RWStepKinematics_RWKinematicPropertyMechanismRepresentation::RWStepKinematics_RWKinematicPropertyMechanismRepresentation() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWKinematicPropertyMechanismRepresentation::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_KinematicPropertyMechanismRepresentation)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,3,theArch,"kinematic_property_mechanism_representation") ) return;
+
+ // Inherited fields of PropertyDefinitionRepresentation
+
+ StepRepr_RepresentedDefinition aPropertyDefinitionRepresentation_Definition;
+ theData->ReadEntity (theNum, 1, "property_definition_representation.definition", theArch, aPropertyDefinitionRepresentation_Definition);
+
+ Handle(StepRepr_Representation) aPropertyDefinitionRepresentation_UsedRepresentation;
+ theData->ReadEntity (theNum, 2, "property_definition_representation.used_representation", theArch, STANDARD_TYPE(StepRepr_Representation), aPropertyDefinitionRepresentation_UsedRepresentation);
+
+ // Own fields of KinematicPropertyMechanismRepresentation
+
+ Handle(StepKinematics_KinematicLinkRepresentation) aBase;
+ theData->ReadEntity (theNum, 3, "base", theArch, STANDARD_TYPE(StepKinematics_KinematicLinkRepresentation), aBase);
+
+ // Initialize entity
+ theEnt->Init(aPropertyDefinitionRepresentation_Definition,
+ aPropertyDefinitionRepresentation_UsedRepresentation,
+ aBase);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWKinematicPropertyMechanismRepresentation::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_KinematicPropertyMechanismRepresentation)& theEnt) const
+{
+
+ // Own fields of PropertyDefinitionRepresentation
+
+ theSW.Send (theEnt->Definition().Value());
+
+ theSW.Send (theEnt->UsedRepresentation());
+
+ // Own fields of KinematicPropertyMechanismRepresentation
+
+ theSW.Send (theEnt->Base());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWKinematicPropertyMechanismRepresentation::Share (const Handle(StepKinematics_KinematicPropertyMechanismRepresentation)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of PropertyDefinitionRepresentation
+
+ iter.AddItem (theEnt->StepRepr_PropertyDefinitionRepresentation::Definition().Value());
+
+ iter.AddItem (theEnt->StepRepr_PropertyDefinitionRepresentation::UsedRepresentation());
+
+ // Own fields of KinematicPropertyMechanismRepresentation
+
+ iter.AddItem (theEnt->Base());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWKinematicPropertyMechanismRepresentation_HeaderFile_
+#define _RWStepKinematics_RWKinematicPropertyMechanismRepresentation_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_KinematicPropertyMechanismRepresentation;
+
+//! Read & Write tool for KinematicPropertyMechanismRepresentation
+class RWStepKinematics_RWKinematicPropertyMechanismRepresentation
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWKinematicPropertyMechanismRepresentation();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_KinematicPropertyMechanismRepresentation)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_KinematicPropertyMechanismRepresentation)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_KinematicPropertyMechanismRepresentation)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWKinematicPropertyMechanismRepresentation_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWKinematicTopologyDirectedStructure.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_KinematicTopologyDirectedStructure.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_RepresentationContext.hxx>
+#include <StepKinematics_KinematicTopologyStructure.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWKinematicTopologyDirectedStructure
+//purpose :
+//=======================================================================
+RWStepKinematics_RWKinematicTopologyDirectedStructure::RWStepKinematics_RWKinematicTopologyDirectedStructure() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWKinematicTopologyDirectedStructure::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_KinematicTopologyDirectedStructure)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,4,theArch,"kinematic_topology_directed_structure") ) return;
+
+ // Inherited fields of Representation
+
+ Handle(TCollection_HAsciiString) aRepresentation_Name;
+ theData->ReadString (theNum, 1, "representation.name", theArch, aRepresentation_Name);
+
+ Handle(StepRepr_HArray1OfRepresentationItem) aRepresentation_Items;
+ Standard_Integer sub2 = 0;
+ if ( theData->ReadSubList (theNum, 2, "representation.items", theArch, sub2) ) {
+ Standard_Integer nb0 = theData->NbParams(sub2);
+ aRepresentation_Items = new StepRepr_HArray1OfRepresentationItem (1, nb0);
+ Standard_Integer num2 = sub2;
+ for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
+ Handle(StepRepr_RepresentationItem) anIt0;
+ theData->ReadEntity (num2, i0, "representation_item", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), anIt0);
+ aRepresentation_Items->SetValue(i0, anIt0);
+ }
+ }
+
+ Handle(StepRepr_RepresentationContext) aRepresentation_ContextOfItems;
+ theData->ReadEntity (theNum, 3, "representation.context_of_items", theArch, STANDARD_TYPE(StepRepr_RepresentationContext), aRepresentation_ContextOfItems);
+
+ // Own fields of KinematicTopologyDirectedStructure
+
+ Handle(StepKinematics_KinematicTopologyStructure) aParent;
+ theData->ReadEntity (theNum, 4, "parent", theArch, STANDARD_TYPE(StepKinematics_KinematicTopologyStructure), aParent);
+
+ // Initialize entity
+ theEnt->Init(aRepresentation_Name,
+ aRepresentation_Items,
+ aRepresentation_ContextOfItems,
+ aParent);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWKinematicTopologyDirectedStructure::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_KinematicTopologyDirectedStructure)& theEnt) const
+{
+
+ // Own fields of Representation
+
+ theSW.Send (theEnt->Name());
+
+ theSW.OpenSub();
+ for (Standard_Integer i1=1; i1 <= theEnt->Items()->Length(); i1++ ) {
+ Handle(StepRepr_RepresentationItem) Var0 = theEnt->Items()->Value(i1);
+ theSW.Send (Var0);
+ }
+ theSW.CloseSub();
+
+ theSW.Send (theEnt->ContextOfItems());
+
+ // Own fields of KinematicTopologyDirectedStructure
+
+ theSW.Send (theEnt->Parent());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWKinematicTopologyDirectedStructure::Share (const Handle(StepKinematics_KinematicTopologyDirectedStructure)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of Representation
+
+ for (Standard_Integer i1=1; i1 <= theEnt->StepRepr_Representation::Items()->Length(); i1++ ) {
+ Handle(StepRepr_RepresentationItem) Var0 = theEnt->StepRepr_Representation::Items()->Value(i1);
+ iter.AddItem (Var0);
+ }
+
+ iter.AddItem (theEnt->StepRepr_Representation::ContextOfItems());
+
+ // Own fields of KinematicTopologyDirectedStructure
+
+ iter.AddItem (theEnt->Parent());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWKinematicTopologyDirectedStructure_HeaderFile_
+#define _RWStepKinematics_RWKinematicTopologyDirectedStructure_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_KinematicTopologyDirectedStructure;
+
+//! Read & Write tool for KinematicTopologyDirectedStructure
+class RWStepKinematics_RWKinematicTopologyDirectedStructure
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWKinematicTopologyDirectedStructure();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_KinematicTopologyDirectedStructure)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_KinematicTopologyDirectedStructure)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_KinematicTopologyDirectedStructure)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWKinematicTopologyDirectedStructure_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWKinematicTopologyNetworkStructure.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_KinematicTopologyNetworkStructure.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_RepresentationContext.hxx>
+#include <StepKinematics_KinematicTopologyStructure.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWKinematicTopologyNetworkStructure
+//purpose :
+//=======================================================================
+RWStepKinematics_RWKinematicTopologyNetworkStructure::RWStepKinematics_RWKinematicTopologyNetworkStructure() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWKinematicTopologyNetworkStructure::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_KinematicTopologyNetworkStructure)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,4,theArch,"kinematic_topology_network_structure") ) return;
+
+ // Inherited fields of Representation
+
+ Handle(TCollection_HAsciiString) aRepresentation_Name;
+ theData->ReadString (theNum, 1, "representation.name", theArch, aRepresentation_Name);
+
+ Handle(StepRepr_HArray1OfRepresentationItem) aRepresentation_Items;
+ Standard_Integer sub2 = 0;
+ if ( theData->ReadSubList (theNum, 2, "representation.items", theArch, sub2) ) {
+ Standard_Integer nb0 = theData->NbParams(sub2);
+ aRepresentation_Items = new StepRepr_HArray1OfRepresentationItem (1, nb0);
+ Standard_Integer num2 = sub2;
+ for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
+ Handle(StepRepr_RepresentationItem) anIt0;
+ theData->ReadEntity (num2, i0, "representation_item", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), anIt0);
+ aRepresentation_Items->SetValue(i0, anIt0);
+ }
+ }
+
+ Handle(StepRepr_RepresentationContext) aRepresentation_ContextOfItems;
+ theData->ReadEntity (theNum, 3, "representation.context_of_items", theArch, STANDARD_TYPE(StepRepr_RepresentationContext), aRepresentation_ContextOfItems);
+
+ // Own fields of KinematicTopologyNetworkStructure
+
+ Handle(StepKinematics_KinematicTopologyStructure) aParent;
+ theData->ReadEntity (theNum, 4, "parent", theArch, STANDARD_TYPE(StepKinematics_KinematicTopologyStructure), aParent);
+
+ // Initialize entity
+ theEnt->Init(aRepresentation_Name,
+ aRepresentation_Items,
+ aRepresentation_ContextOfItems,
+ aParent);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWKinematicTopologyNetworkStructure::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_KinematicTopologyNetworkStructure)& theEnt) const
+{
+
+ // Own fields of Representation
+
+ theSW.Send (theEnt->Name());
+
+ theSW.OpenSub();
+ for (Standard_Integer i1=1; i1 <= theEnt->Items()->Length(); i1++ ) {
+ Handle(StepRepr_RepresentationItem) Var0 = theEnt->Items()->Value(i1);
+ theSW.Send (Var0);
+ }
+ theSW.CloseSub();
+
+ theSW.Send (theEnt->ContextOfItems());
+
+ // Own fields of KinematicTopologyNetworkStructure
+
+ theSW.Send (theEnt->Parent());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWKinematicTopologyNetworkStructure::Share (const Handle(StepKinematics_KinematicTopologyNetworkStructure)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of Representation
+
+ for (Standard_Integer i1=1; i1 <= theEnt->StepRepr_Representation::Items()->Length(); i1++ ) {
+ Handle(StepRepr_RepresentationItem) Var0 = theEnt->StepRepr_Representation::Items()->Value(i1);
+ iter.AddItem (Var0);
+ }
+
+ iter.AddItem (theEnt->StepRepr_Representation::ContextOfItems());
+
+ // Own fields of KinematicTopologyNetworkStructure
+
+ iter.AddItem (theEnt->Parent());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWKinematicTopologyNetworkStructure_HeaderFile_
+#define _RWStepKinematics_RWKinematicTopologyNetworkStructure_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_KinematicTopologyNetworkStructure;
+
+//! Read & Write tool for KinematicTopologyNetworkStructure
+class RWStepKinematics_RWKinematicTopologyNetworkStructure
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWKinematicTopologyNetworkStructure();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_KinematicTopologyNetworkStructure)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_KinematicTopologyNetworkStructure)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_KinematicTopologyNetworkStructure)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWKinematicTopologyNetworkStructure_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWKinematicTopologyStructure.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_KinematicTopologyStructure.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_RepresentationContext.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWKinematicTopologyStructure
+//purpose :
+//=======================================================================
+RWStepKinematics_RWKinematicTopologyStructure::RWStepKinematics_RWKinematicTopologyStructure() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWKinematicTopologyStructure::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_KinematicTopologyStructure)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,3,theArch,"kinematic_topology_structure") ) return;
+
+ // Inherited fields of Representation
+
+ Handle(TCollection_HAsciiString) aRepresentation_Name;
+ theData->ReadString (theNum, 1, "representation.name", theArch, aRepresentation_Name);
+
+ Handle(StepRepr_HArray1OfRepresentationItem) aRepresentation_Items;
+ Standard_Integer sub2 = 0;
+ if ( theData->ReadSubList (theNum, 2, "representation.items", theArch, sub2) ) {
+ Standard_Integer nb0 = theData->NbParams(sub2);
+ aRepresentation_Items = new StepRepr_HArray1OfRepresentationItem (1, nb0);
+ Standard_Integer num2 = sub2;
+ for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
+ Handle(StepRepr_RepresentationItem) anIt0;
+ theData->ReadEntity (num2, i0, "representation_item", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), anIt0);
+ aRepresentation_Items->SetValue(i0, anIt0);
+ }
+ }
+
+ Handle(StepRepr_RepresentationContext) aRepresentation_ContextOfItems;
+ theData->ReadEntity (theNum, 3, "representation.context_of_items", theArch, STANDARD_TYPE(StepRepr_RepresentationContext), aRepresentation_ContextOfItems);
+
+ // Initialize entity
+ theEnt->Init(aRepresentation_Name,
+ aRepresentation_Items,
+ aRepresentation_ContextOfItems);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWKinematicTopologyStructure::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_KinematicTopologyStructure)& theEnt) const
+{
+
+ // Own fields of Representation
+
+ theSW.Send (theEnt->Name());
+
+ theSW.OpenSub();
+ for (Standard_Integer i1=1; i1 <= theEnt->Items()->Length(); i1++ ) {
+ Handle(StepRepr_RepresentationItem) Var0 = theEnt->Items()->Value(i1);
+ theSW.Send (Var0);
+ }
+ theSW.CloseSub();
+
+ theSW.Send (theEnt->ContextOfItems());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWKinematicTopologyStructure::Share (const Handle(StepKinematics_KinematicTopologyStructure)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of Representation
+
+ for (Standard_Integer i1=1; i1 <= theEnt->StepRepr_Representation::Items()->Length(); i1++ ) {
+ Handle(StepRepr_RepresentationItem) Var0 = theEnt->StepRepr_Representation::Items()->Value(i1);
+ iter.AddItem (Var0);
+ }
+
+ iter.AddItem (theEnt->StepRepr_Representation::ContextOfItems());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWKinematicTopologyStructure_HeaderFile_
+#define _RWStepKinematics_RWKinematicTopologyStructure_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_KinematicTopologyStructure;
+
+//! Read & Write tool for KinematicTopologyStructure
+class RWStepKinematics_RWKinematicTopologyStructure
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWKinematicTopologyStructure();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_KinematicTopologyStructure)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_KinematicTopologyStructure)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_KinematicTopologyStructure)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWKinematicTopologyStructure_HeaderFile_
--- /dev/null
+// Created on : Fri May 08 19:02:07 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWLinearFlexibleAndPinionPair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_LinearFlexibleAndPinionPair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWLinearFlexibleAndPinionPair
+//purpose :
+//=======================================================================
+RWStepKinematics_RWLinearFlexibleAndPinionPair::RWStepKinematics_RWLinearFlexibleAndPinionPair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWLinearFlexibleAndPinionPair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_LinearFlexibleAndPinionPair)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,7,theArch,"linear_flexible_and_pinion_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Own fields of LinearFlexibleAndPinionPair
+
+ Standard_Real aPinionRadius;
+ theData->ReadReal (theNum, 7, "pinion_radius", theArch, aPinionRadius);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aPinionRadius);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWLinearFlexibleAndPinionPair::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_LinearFlexibleAndPinionPair)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of LinearFlexibleAndPinionPair
+
+ theSW.Send (theEnt->PinionRadius());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWLinearFlexibleAndPinionPair::Share (const Handle(StepKinematics_LinearFlexibleAndPinionPair)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Own fields of LinearFlexibleAndPinionPair
+}
--- /dev/null
+// Created on : Fri May 08 19:02:07 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWLinearFlexibleAndPinionPair_HeaderFile_
+#define _RWStepKinematics_RWLinearFlexibleAndPinionPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_LinearFlexibleAndPinionPair;
+
+//! Read & Write tool for LinearFlexibleAndPinionPair
+class RWStepKinematics_RWLinearFlexibleAndPinionPair
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWLinearFlexibleAndPinionPair();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_LinearFlexibleAndPinionPair)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_LinearFlexibleAndPinionPair)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_LinearFlexibleAndPinionPair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWLinearFlexibleAndPinionPair_HeaderFile_
--- /dev/null
+// Created on : Fri May 08 19:02:07 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_LinearFlexibleAndPlanarCurvePair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Curve.hxx>
+#include <Standard_Boolean.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair
+//purpose :
+//=======================================================================
+RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair::RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_LinearFlexibleAndPlanarCurvePair)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,8,theArch,"linear_flexible_and_planar_curve_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Own fields of LinearFlexibleAndPlanarCurvePair
+
+ Handle(StepGeom_Curve) aPairCurve;
+ theData->ReadEntity (theNum, 7, "pair_curve", theArch, STANDARD_TYPE(StepGeom_Curve), aPairCurve);
+
+ Standard_Boolean aOrientation;
+ theData->ReadBoolean (theNum, 8, "orientation", theArch, aOrientation);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aPairCurve,
+ aOrientation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_LinearFlexibleAndPlanarCurvePair)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of LinearFlexibleAndPlanarCurvePair
+
+ theSW.Send (theEnt->PairCurve());
+
+ theSW.SendBoolean (theEnt->Orientation());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair::Share (const Handle(StepKinematics_LinearFlexibleAndPlanarCurvePair)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Own fields of LinearFlexibleAndPlanarCurvePair
+
+ iter.AddItem (theEnt->PairCurve());
+}
--- /dev/null
+// Created on : Fri May 08 19:02:07 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair_HeaderFile_
+#define _RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_LinearFlexibleAndPlanarCurvePair;
+
+//! Read & Write tool for LinearFlexibleAndPlanarCurvePair
+class RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_LinearFlexibleAndPlanarCurvePair)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_LinearFlexibleAndPlanarCurvePair)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_LinearFlexibleAndPlanarCurvePair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair_HeaderFile_
--- /dev/null
+// Created on : Fri May 08 19:02:07 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWLinearFlexibleLinkRepresentation.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_LinearFlexibleLinkRepresentation.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_RepresentationContext.hxx>
+#include <StepKinematics_KinematicLink.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWLinearFlexibleLinkRepresentation
+//purpose :
+//=======================================================================
+RWStepKinematics_RWLinearFlexibleLinkRepresentation::RWStepKinematics_RWLinearFlexibleLinkRepresentation() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWLinearFlexibleLinkRepresentation::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_LinearFlexibleLinkRepresentation)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,4,theArch,"linear_flexible_link_representation") ) return;
+
+ // Inherited fields of Representation
+
+ Handle(TCollection_HAsciiString) aRepresentation_Name;
+ theData->ReadString (theNum, 1, "representation.name", theArch, aRepresentation_Name);
+
+ Handle(StepRepr_HArray1OfRepresentationItem) aRepresentation_Items;
+ Standard_Integer sub2 = 0;
+ if ( theData->ReadSubList (theNum, 2, "representation.items", theArch, sub2) ) {
+ Standard_Integer nb0 = theData->NbParams(sub2);
+ aRepresentation_Items = new StepRepr_HArray1OfRepresentationItem (1, nb0);
+ Standard_Integer num2 = sub2;
+ for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
+ Handle(StepRepr_RepresentationItem) anIt0;
+ theData->ReadEntity (num2, i0, "representation_item", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), anIt0);
+ aRepresentation_Items->SetValue(i0, anIt0);
+ }
+ }
+
+ Handle(StepRepr_RepresentationContext) aRepresentation_ContextOfItems;
+ theData->ReadEntity (theNum, 3, "representation.context_of_items", theArch, STANDARD_TYPE(StepRepr_RepresentationContext), aRepresentation_ContextOfItems);
+
+ // Inherited fields of KinematicLinkRepresentation
+
+ Handle(StepKinematics_KinematicLink) aKinematicLinkRepresentation_RepresentedLink;
+ theData->ReadEntity (theNum, 4, "kinematic_link_representation.represented_link", theArch, STANDARD_TYPE(StepKinematics_KinematicLink), aKinematicLinkRepresentation_RepresentedLink);
+
+ // Initialize entity
+ theEnt->Init(aRepresentation_Name,
+ aRepresentation_Items,
+ aRepresentation_ContextOfItems,
+ aKinematicLinkRepresentation_RepresentedLink);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWLinearFlexibleLinkRepresentation::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_LinearFlexibleLinkRepresentation)& theEnt) const
+{
+
+ // Own fields of Representation
+
+ theSW.Send (theEnt->Name());
+
+ theSW.OpenSub();
+ for (Standard_Integer i1=1; i1 <= theEnt->Items()->Length(); i1++ ) {
+ Handle(StepRepr_RepresentationItem) Var0 = theEnt->Items()->Value(i1);
+ theSW.Send (Var0);
+ }
+ theSW.CloseSub();
+
+ theSW.Send (theEnt->ContextOfItems());
+
+ // Own fields of KinematicLinkRepresentation
+
+ theSW.Send (theEnt->RepresentedLink());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWLinearFlexibleLinkRepresentation::Share (const Handle(StepKinematics_LinearFlexibleLinkRepresentation)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of Representation
+
+ for (Standard_Integer i1=1; i1 <= theEnt->StepRepr_Representation::Items()->Length(); i1++ ) {
+ Handle(StepRepr_RepresentationItem) Var0 = theEnt->StepRepr_Representation::Items()->Value(i1);
+ iter.AddItem (Var0);
+ }
+
+ iter.AddItem (theEnt->StepRepr_Representation::ContextOfItems());
+
+ // Inherited fields of KinematicLinkRepresentation
+
+ iter.AddItem (theEnt->StepKinematics_KinematicLinkRepresentation::RepresentedLink());
+}
--- /dev/null
+// Created on : Fri May 08 19:02:07 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWLinearFlexibleLinkRepresentation_HeaderFile_
+#define _RWStepKinematics_RWLinearFlexibleLinkRepresentation_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_LinearFlexibleLinkRepresentation;
+
+//! Read & Write tool for LinearFlexibleLinkRepresentation
+class RWStepKinematics_RWLinearFlexibleLinkRepresentation
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWLinearFlexibleLinkRepresentation();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_LinearFlexibleLinkRepresentation)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_LinearFlexibleLinkRepresentation)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_LinearFlexibleLinkRepresentation)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWLinearFlexibleLinkRepresentation_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWLowOrderKinematicPair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_LowOrderKinematicPair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWLowOrderKinematicPair
+//purpose :
+//=======================================================================
+RWStepKinematics_RWLowOrderKinematicPair::RWStepKinematics_RWLowOrderKinematicPair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWLowOrderKinematicPair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_LowOrderKinematicPair)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,12,theArch,"low_order_kinematic_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Own fields of LowOrderKinematicPair
+
+ Standard_Boolean aTX;
+ theData->ReadBoolean (theNum, 7, "t_x", theArch, aTX);
+
+ Standard_Boolean aTY;
+ theData->ReadBoolean (theNum, 8, "t_y", theArch, aTY);
+
+ Standard_Boolean aTZ;
+ theData->ReadBoolean (theNum, 9, "t_z", theArch, aTZ);
+
+ Standard_Boolean aRX;
+ theData->ReadBoolean (theNum, 10, "r_x", theArch, aRX);
+
+ Standard_Boolean aRY;
+ theData->ReadBoolean (theNum, 11, "r_y", theArch, aRY);
+
+ Standard_Boolean aRZ;
+ theData->ReadBoolean (theNum, 12, "r_z", theArch, aRZ);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aTX,
+ aTY,
+ aTZ,
+ aRX,
+ aRY,
+ aRZ);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWLowOrderKinematicPair::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_LowOrderKinematicPair)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ theSW.SendBoolean (theEnt->TX());
+
+ theSW.SendBoolean (theEnt->TY());
+
+ theSW.SendBoolean (theEnt->TZ());
+
+ theSW.SendBoolean (theEnt->RX());
+
+ theSW.SendBoolean (theEnt->RY());
+
+ theSW.SendBoolean (theEnt->RZ());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWLowOrderKinematicPair::Share (const Handle(StepKinematics_LowOrderKinematicPair)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Own fields of LowOrderKinematicPair
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWLowOrderKinematicPair_HeaderFile_
+#define _RWStepKinematics_RWLowOrderKinematicPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_LowOrderKinematicPair;
+
+//! Read & Write tool for LowOrderKinematicPair
+class RWStepKinematics_RWLowOrderKinematicPair
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWLowOrderKinematicPair();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_LowOrderKinematicPair)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_LowOrderKinematicPair)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_LowOrderKinematicPair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWLowOrderKinematicPair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWLowOrderKinematicPairValue.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_LowOrderKinematicPairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWLowOrderKinematicPairValue
+//purpose :
+//=======================================================================
+RWStepKinematics_RWLowOrderKinematicPairValue::RWStepKinematics_RWLowOrderKinematicPairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWLowOrderKinematicPairValue::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_LowOrderKinematicPairValue)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,8,theArch,"low_order_kinematic_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Own fields of LowOrderKinematicPairValue
+
+ Standard_Real aActualTranslationX;
+ theData->ReadReal (theNum, 3, "actual_translation_x", theArch, aActualTranslationX);
+
+ Standard_Real aActualTranslationY;
+ theData->ReadReal (theNum, 4, "actual_translation_y", theArch, aActualTranslationY);
+
+ Standard_Real aActualTranslationZ;
+ theData->ReadReal (theNum, 5, "actual_translation_z", theArch, aActualTranslationZ);
+
+ Standard_Real aActualRotationX;
+ theData->ReadReal (theNum, 6, "actual_rotation_x", theArch, aActualRotationX);
+
+ Standard_Real aActualRotationY;
+ theData->ReadReal (theNum, 7, "actual_rotation_y", theArch, aActualRotationY);
+
+ Standard_Real aActualRotationZ;
+ theData->ReadReal (theNum, 8, "actual_rotation_z", theArch, aActualRotationZ);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair,
+ aActualTranslationX,
+ aActualTranslationY,
+ aActualTranslationZ,
+ aActualRotationX,
+ aActualRotationY,
+ aActualRotationZ);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWLowOrderKinematicPairValue::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_LowOrderKinematicPairValue)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Own fields of PairValue
+
+ theSW.Send (theEnt->AppliesToPair());
+
+ // Own fields of LowOrderKinematicPairValue
+
+ theSW.Send (theEnt->ActualTranslationX());
+
+ theSW.Send (theEnt->ActualTranslationY());
+
+ theSW.Send (theEnt->ActualTranslationZ());
+
+ theSW.Send (theEnt->ActualRotationX());
+
+ theSW.Send (theEnt->ActualRotationY());
+
+ theSW.Send (theEnt->ActualRotationZ());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWLowOrderKinematicPairValue::Share (const Handle(StepKinematics_LowOrderKinematicPairValue)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair());
+
+ // Own fields of LowOrderKinematicPairValue
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWLowOrderKinematicPairValue_HeaderFile_
+#define _RWStepKinematics_RWLowOrderKinematicPairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_LowOrderKinematicPairValue;
+
+//! Read & Write tool for LowOrderKinematicPairValue
+class RWStepKinematics_RWLowOrderKinematicPairValue
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWLowOrderKinematicPairValue();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_LowOrderKinematicPairValue)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_LowOrderKinematicPairValue)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_LowOrderKinematicPairValue)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWLowOrderKinematicPairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWLowOrderKinematicPairWithRange.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_LowOrderKinematicPairWithRange.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWLowOrderKinematicPairWithRange
+//purpose :
+//=======================================================================
+RWStepKinematics_RWLowOrderKinematicPairWithRange::RWStepKinematics_RWLowOrderKinematicPairWithRange() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWLowOrderKinematicPairWithRange::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_LowOrderKinematicPairWithRange)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,24,theArch,"low_order_kinematic_pair_with_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ);
+
+ // Own fields of LowOrderKinematicPairWithRange
+
+ Standard_Real aLowerLimitActualRotationX;
+ Standard_Boolean hasLowerLimitActualRotationX = Standard_True;
+ if ( theData->IsParamDefined (theNum,13) ) {
+ theData->ReadReal (theNum, 13, "lower_limit_actual_rotation_x", theArch, aLowerLimitActualRotationX);
+ }
+ else {
+ hasLowerLimitActualRotationX = Standard_False;
+ aLowerLimitActualRotationX = 0;
+ }
+
+ Standard_Real aUpperLimitActualRotationX;
+ Standard_Boolean hasUpperLimitActualRotationX = Standard_True;
+ if ( theData->IsParamDefined (theNum,14) ) {
+ theData->ReadReal (theNum, 14, "upper_limit_actual_rotation_x", theArch, aUpperLimitActualRotationX);
+ }
+ else {
+ hasUpperLimitActualRotationX = Standard_False;
+ aUpperLimitActualRotationX = 0;
+ }
+
+ Standard_Real aLowerLimitActualRotationY;
+ Standard_Boolean hasLowerLimitActualRotationY = Standard_True;
+ if ( theData->IsParamDefined (theNum,15) ) {
+ theData->ReadReal (theNum, 15, "lower_limit_actual_rotation_y", theArch, aLowerLimitActualRotationY);
+ }
+ else {
+ hasLowerLimitActualRotationY = Standard_False;
+ aLowerLimitActualRotationY = 0;
+ }
+
+ Standard_Real aUpperLimitActualRotationY;
+ Standard_Boolean hasUpperLimitActualRotationY = Standard_True;
+ if ( theData->IsParamDefined (theNum,16) ) {
+ theData->ReadReal (theNum, 16, "upper_limit_actual_rotation_y", theArch, aUpperLimitActualRotationY);
+ }
+ else {
+ hasUpperLimitActualRotationY = Standard_False;
+ aUpperLimitActualRotationY = 0;
+ }
+
+ Standard_Real aLowerLimitActualRotationZ;
+ Standard_Boolean hasLowerLimitActualRotationZ = Standard_True;
+ if ( theData->IsParamDefined (theNum,17) ) {
+ theData->ReadReal (theNum, 17, "lower_limit_actual_rotation_z", theArch, aLowerLimitActualRotationZ);
+ }
+ else {
+ hasLowerLimitActualRotationZ = Standard_False;
+ aLowerLimitActualRotationZ = 0;
+ }
+
+ Standard_Real aUpperLimitActualRotationZ;
+ Standard_Boolean hasUpperLimitActualRotationZ = Standard_True;
+ if ( theData->IsParamDefined (theNum,18) ) {
+ theData->ReadReal (theNum, 18, "upper_limit_actual_rotation_z", theArch, aUpperLimitActualRotationZ);
+ }
+ else {
+ hasUpperLimitActualRotationZ = Standard_False;
+ aUpperLimitActualRotationZ = 0;
+ }
+
+ Standard_Real aLowerLimitActualTranslationX;
+ Standard_Boolean hasLowerLimitActualTranslationX = Standard_True;
+ if ( theData->IsParamDefined (theNum,19) ) {
+ theData->ReadReal (theNum, 19, "lower_limit_actual_translation_x", theArch, aLowerLimitActualTranslationX);
+ }
+ else {
+ hasLowerLimitActualTranslationX = Standard_False;
+ aLowerLimitActualTranslationX = 0;
+ }
+
+ Standard_Real aUpperLimitActualTranslationX;
+ Standard_Boolean hasUpperLimitActualTranslationX = Standard_True;
+ if ( theData->IsParamDefined (theNum,20) ) {
+ theData->ReadReal (theNum, 20, "upper_limit_actual_translation_x", theArch, aUpperLimitActualTranslationX);
+ }
+ else {
+ hasUpperLimitActualTranslationX = Standard_False;
+ aUpperLimitActualTranslationX = 0;
+ }
+
+ Standard_Real aLowerLimitActualTranslationY;
+ Standard_Boolean hasLowerLimitActualTranslationY = Standard_True;
+ if ( theData->IsParamDefined (theNum,21) ) {
+ theData->ReadReal (theNum, 21, "lower_limit_actual_translation_y", theArch, aLowerLimitActualTranslationY);
+ }
+ else {
+ hasLowerLimitActualTranslationY = Standard_False;
+ aLowerLimitActualTranslationY = 0;
+ }
+
+ Standard_Real aUpperLimitActualTranslationY;
+ Standard_Boolean hasUpperLimitActualTranslationY = Standard_True;
+ if ( theData->IsParamDefined (theNum,22) ) {
+ theData->ReadReal (theNum, 22, "upper_limit_actual_translation_y", theArch, aUpperLimitActualTranslationY);
+ }
+ else {
+ hasUpperLimitActualTranslationY = Standard_False;
+ aUpperLimitActualTranslationY = 0;
+ }
+
+ Standard_Real aLowerLimitActualTranslationZ;
+ Standard_Boolean hasLowerLimitActualTranslationZ = Standard_True;
+ if ( theData->IsParamDefined (theNum,23) ) {
+ theData->ReadReal (theNum, 23, "lower_limit_actual_translation_z", theArch, aLowerLimitActualTranslationZ);
+ }
+ else {
+ hasLowerLimitActualTranslationZ = Standard_False;
+ aLowerLimitActualTranslationZ = 0;
+ }
+
+ Standard_Real aUpperLimitActualTranslationZ;
+ Standard_Boolean hasUpperLimitActualTranslationZ = Standard_True;
+ if ( theData->IsParamDefined (theNum,24) ) {
+ theData->ReadReal (theNum, 24, "upper_limit_actual_translation_z", theArch, aUpperLimitActualTranslationZ);
+ }
+ else {
+ hasUpperLimitActualTranslationZ = Standard_False;
+ aUpperLimitActualTranslationZ = 0;
+ }
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ,
+ hasLowerLimitActualRotationX,
+ aLowerLimitActualRotationX,
+ hasUpperLimitActualRotationX,
+ aUpperLimitActualRotationX,
+ hasLowerLimitActualRotationY,
+ aLowerLimitActualRotationY,
+ hasUpperLimitActualRotationY,
+ aUpperLimitActualRotationY,
+ hasLowerLimitActualRotationZ,
+ aLowerLimitActualRotationZ,
+ hasUpperLimitActualRotationZ,
+ aUpperLimitActualRotationZ,
+ hasLowerLimitActualTranslationX,
+ aLowerLimitActualTranslationX,
+ hasUpperLimitActualTranslationX,
+ aUpperLimitActualTranslationX,
+ hasLowerLimitActualTranslationY,
+ aLowerLimitActualTranslationY,
+ hasUpperLimitActualTranslationY,
+ aUpperLimitActualTranslationY,
+ hasLowerLimitActualTranslationZ,
+ aLowerLimitActualTranslationZ,
+ hasUpperLimitActualTranslationZ,
+ aUpperLimitActualTranslationZ);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWLowOrderKinematicPairWithRange::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_LowOrderKinematicPairWithRange)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ theSW.SendBoolean (theEnt->TX());
+
+ theSW.SendBoolean (theEnt->TY());
+
+ theSW.SendBoolean (theEnt->TZ());
+
+ theSW.SendBoolean (theEnt->RX());
+
+ theSW.SendBoolean (theEnt->RY());
+
+ theSW.SendBoolean (theEnt->RZ());
+
+ // Own fields of LowOrderKinematicPairWithRange
+
+ if ( theEnt->HasLowerLimitActualRotationX() ) {
+ theSW.Send (theEnt->LowerLimitActualRotationX());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitActualRotationX() ) {
+ theSW.Send (theEnt->UpperLimitActualRotationX());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasLowerLimitActualRotationY() ) {
+ theSW.Send (theEnt->LowerLimitActualRotationY());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitActualRotationY() ) {
+ theSW.Send (theEnt->UpperLimitActualRotationY());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasLowerLimitActualRotationZ() ) {
+ theSW.Send (theEnt->LowerLimitActualRotationZ());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitActualRotationZ() ) {
+ theSW.Send (theEnt->UpperLimitActualRotationZ());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasLowerLimitActualTranslationX() ) {
+ theSW.Send (theEnt->LowerLimitActualTranslationX());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitActualTranslationX() ) {
+ theSW.Send (theEnt->UpperLimitActualTranslationX());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasLowerLimitActualTranslationY() ) {
+ theSW.Send (theEnt->LowerLimitActualTranslationY());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitActualTranslationY() ) {
+ theSW.Send (theEnt->UpperLimitActualTranslationY());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasLowerLimitActualTranslationZ() ) {
+ theSW.Send (theEnt->LowerLimitActualTranslationZ());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitActualTranslationZ() ) {
+ theSW.Send (theEnt->UpperLimitActualTranslationZ());
+ }
+ else theSW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWLowOrderKinematicPairWithRange::Share (const Handle(StepKinematics_LowOrderKinematicPairWithRange)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+
+ // Own fields of LowOrderKinematicPairWithRange
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWLowOrderKinematicPairWithRange_HeaderFile_
+#define _RWStepKinematics_RWLowOrderKinematicPairWithRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_LowOrderKinematicPairWithRange;
+
+//! Read & Write tool for LowOrderKinematicPairWithRange
+class RWStepKinematics_RWLowOrderKinematicPairWithRange
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWLowOrderKinematicPairWithRange();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_LowOrderKinematicPairWithRange)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_LowOrderKinematicPairWithRange)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_LowOrderKinematicPairWithRange)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWLowOrderKinematicPairWithRange_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWMechanismRepresentation.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_MechanismRepresentation.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_RepresentationContext.hxx>
+#include <StepKinematics_KinematicTopologyRepresentationSelect.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWMechanismRepresentation
+//purpose :
+//=======================================================================
+RWStepKinematics_RWMechanismRepresentation::RWStepKinematics_RWMechanismRepresentation() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWMechanismRepresentation::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_MechanismRepresentation)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,4,theArch,"mechanism_representation") ) return;
+
+ // Inherited fields of Representation
+
+ Handle(TCollection_HAsciiString) aRepresentation_Name;
+ theData->ReadString (theNum, 1, "representation.name", theArch, aRepresentation_Name);
+
+ Handle(StepRepr_HArray1OfRepresentationItem) aRepresentation_Items;
+ Standard_Integer sub2 = 0;
+ if ( theData->ReadSubList (theNum, 2, "representation.items", theArch, sub2) ) {
+ Standard_Integer nb0 = theData->NbParams(sub2);
+ aRepresentation_Items = new StepRepr_HArray1OfRepresentationItem (1, nb0);
+ Standard_Integer num2 = sub2;
+ for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
+ Handle(StepRepr_RepresentationItem) anIt0;
+ theData->ReadEntity (num2, i0, "representation_item", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), anIt0);
+ aRepresentation_Items->SetValue(i0, anIt0);
+ }
+ }
+
+ Handle(StepRepr_RepresentationContext) aRepresentation_ContextOfItems;
+ theData->ReadEntity (theNum, 3, "representation.context_of_items", theArch, STANDARD_TYPE(StepRepr_RepresentationContext), aRepresentation_ContextOfItems);
+
+ // Own fields of MechanismRepresentation
+
+ StepKinematics_KinematicTopologyRepresentationSelect aRepresentedTopology;
+ theData->ReadEntity (theNum, 4, "represented_topology", theArch, aRepresentedTopology);
+
+ // Initialize entity
+ theEnt->Init(aRepresentation_Name,
+ aRepresentation_Items,
+ aRepresentation_ContextOfItems,
+ aRepresentedTopology);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWMechanismRepresentation::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_MechanismRepresentation)& theEnt) const
+{
+
+ // Own fields of Representation
+
+ theSW.Send (theEnt->Name());
+
+ theSW.OpenSub();
+ for (Standard_Integer i1=1; i1 <= theEnt->Items()->Length(); i1++ ) {
+ Handle(StepRepr_RepresentationItem) Var0 = theEnt->Items()->Value(i1);
+ theSW.Send (Var0);
+ }
+ theSW.CloseSub();
+
+ theSW.Send (theEnt->ContextOfItems());
+
+ // Own fields of MechanismRepresentation
+
+ theSW.Send (theEnt->RepresentedTopology().Value());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWMechanismRepresentation::Share (const Handle(StepKinematics_MechanismRepresentation)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of Representation
+
+ for (Standard_Integer i1=1; i1 <= theEnt->StepRepr_Representation::Items()->Length(); i1++ ) {
+ Handle(StepRepr_RepresentationItem) Var0 = theEnt->StepRepr_Representation::Items()->Value(i1);
+ iter.AddItem (Var0);
+ }
+
+ iter.AddItem (theEnt->StepRepr_Representation::ContextOfItems());
+
+ // Own fields of MechanismRepresentation
+
+ iter.AddItem (theEnt->RepresentedTopology().Value());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWMechanismRepresentation_HeaderFile_
+#define _RWStepKinematics_RWMechanismRepresentation_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_MechanismRepresentation;
+
+//! Read & Write tool for MechanismRepresentation
+class RWStepKinematics_RWMechanismRepresentation
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWMechanismRepresentation();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_MechanismRepresentation)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_MechanismRepresentation)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_MechanismRepresentation)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWMechanismRepresentation_HeaderFile_
--- /dev/null
+// Created on: 2020-06-18
+// Created by: PASUKHIN DMITRY
+// Copyright (c) 2020 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+
+#include <RWStepKinematics_RWMechanismStateRepresentation.hxx>
+
+#include <Interface_Check.hxx>
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_RepresentationContext.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_MechanismStateRepresentation.hxx>
+#include <StepKinematics_MechanismRepresentation.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWMechanismStateRepresentation
+//purpose :
+//=======================================================================
+RWStepKinematics_RWMechanismStateRepresentation::RWStepKinematics_RWMechanismStateRepresentation() {}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWMechanismStateRepresentation::ReadStep
+ (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_MechanismStateRepresentation)& theEnt) const
+{
+ // Number of Parameter Control
+ if (!theData->CheckNbParams(theNum, 4, theArch, "mechanism_state_representation")) return;
+
+ // Inherited field : name
+ Handle(TCollection_HAsciiString) aName;
+ theData->ReadString (theNum, 1, "name" ,theArch, aName);
+
+ // Inherited field : items
+ Handle(StepRepr_HArray1OfRepresentationItem) aItems;
+ Handle(StepRepr_RepresentationItem) anEnt;
+ Standard_Integer nsub;
+ if (theData->ReadSubList (theNum, 2, "items", theArch, nsub)) {
+ Standard_Integer nb = theData->NbParams(nsub);
+ aItems = new StepRepr_HArray1OfRepresentationItem (1, nb);
+ for (Standard_Integer i = 1; i <= nb; i ++) {
+ if (theData->ReadEntity (nsub, i, "representation_item", theArch,
+ STANDARD_TYPE(StepRepr_RepresentationItem), anEnt))
+ aItems->SetValue(i, anEnt);
+ }
+ }
+
+ // Inherited field : context_of_items
+ Handle(StepRepr_RepresentationContext) aContextOfItems;
+ theData->ReadEntity(theNum, 3,"context_of_items", theArch, STANDARD_TYPE(StepRepr_RepresentationContext), aContextOfItems);
+
+ // Inherited field : represented_mechanism
+ Handle(StepKinematics_MechanismRepresentation) aRepresentedMechanism;
+ theData->ReadEntity(theNum, 4, "represented_mechanism", theArch, STANDARD_TYPE(StepKinematics_MechanismRepresentation), aRepresentedMechanism);
+
+ // Initialisation of the read entity
+ theEnt->Init(aName, aItems, aContextOfItems, aRepresentedMechanism);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWMechanismStateRepresentation::WriteStep
+ (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_MechanismStateRepresentation)& theEnt) const
+{
+ // Inherited field : name
+ theSW.Send(theEnt->Name());
+
+ // Inherited field : items
+ theSW.OpenSub();
+ for (Standard_Integer i = 1; i <= theEnt->NbItems(); i++) {
+ theSW.Send(theEnt->ItemsValue(i));
+ }
+ theSW.CloseSub();
+
+ // Inherited field : context_of_items
+ theSW.Send(theEnt->ContextOfItems());
+
+ // Inherited field : represented_mechanism
+ theSW.Send(theEnt->Mechanism());
+
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWMechanismStateRepresentation::Share(const Handle(StepKinematics_MechanismStateRepresentation)& theEnt, Interface_EntityIterator& iter) const
+{
+ Standard_Integer nbElem = theEnt->NbItems();
+ for (Standard_Integer i = 1; i <= nbElem; i++) {
+ iter.GetOneItem(theEnt->ItemsValue(i));
+ }
+ iter.GetOneItem(theEnt->ContextOfItems());
+ iter.GetOneItem(theEnt->Mechanism());
+}
+
--- /dev/null
+// Created on: 2020-06-18
+// Created by: PASUKHIN DMITRY
+// Copyright (c) 2020 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWMechanismStateRepresentation_HeaderFile
+#define _RWStepKinematics_RWMechanismStateRepresentation_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+class StepData_StepReaderData;
+class Interface_Check;
+class StepKinematics_MechanismStateRepresentation;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write Module for MechanismStateRepresentation
+class RWStepKinematics_RWMechanismStateRepresentation
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWMechanismStateRepresentation();
+
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_MechanismStateRepresentation)& theEnt) const;
+
+ Standard_EXPORT void WriteStep (StepData_StepWriter& theSW, const Handle(StepKinematics_MechanismStateRepresentation)& theEnt) const;
+
+ Standard_EXPORT void Share (const Handle(StepKinematics_MechanismStateRepresentation)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWMechanismStateRepresentation_HeaderFile
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWOrientedJoint.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_OrientedJoint.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepShape_Vertex.hxx>
+#include <StepShape_Edge.hxx>
+#include <Standard_Boolean.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWOrientedJoint
+//purpose :
+//=======================================================================
+RWStepKinematics_RWOrientedJoint::RWStepKinematics_RWOrientedJoint() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWOrientedJoint::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_OrientedJoint)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,5,theArch,"oriented_joint") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of Edge
+
+ Handle(StepShape_Vertex) aEdge_EdgeStart;
+ theData->ReadEntity (theNum, 2, "edge.edge_start", theArch, STANDARD_TYPE(StepShape_Vertex), aEdge_EdgeStart);
+
+ Handle(StepShape_Vertex) aEdge_EdgeEnd;
+ theData->ReadEntity (theNum, 3, "edge.edge_end", theArch, STANDARD_TYPE(StepShape_Vertex), aEdge_EdgeEnd);
+
+ // Inherited fields of OrientedEdge
+
+ Handle(StepShape_Edge) aOrientedEdge_EdgeElement;
+ theData->ReadEntity (theNum, 4, "oriented_edge.edge_element", theArch, STANDARD_TYPE(StepShape_Edge), aOrientedEdge_EdgeElement);
+
+ Standard_Boolean aOrientedEdge_Orientation;
+ theData->ReadBoolean (theNum, 5, "oriented_edge.orientation", theArch, aOrientedEdge_Orientation);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aOrientedEdge_EdgeElement,
+ aOrientedEdge_Orientation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWOrientedJoint::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_OrientedJoint)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Own fields of Edge
+
+ theSW.Send (theEnt->EdgeStart());
+
+ theSW.Send (theEnt->EdgeEnd());
+
+ // Own fields of OrientedEdge
+
+ theSW.Send (theEnt->EdgeElement());
+
+ theSW.SendBoolean (theEnt->Orientation());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWOrientedJoint::Share (const Handle(StepKinematics_OrientedJoint)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of Edge
+
+ iter.AddItem (theEnt->StepShape_Edge::EdgeStart());
+
+ iter.AddItem (theEnt->StepShape_Edge::EdgeEnd());
+
+ // Inherited fields of OrientedEdge
+
+ iter.AddItem (theEnt->StepShape_OrientedEdge::EdgeElement());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWOrientedJoint_HeaderFile_
+#define _RWStepKinematics_RWOrientedJoint_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_OrientedJoint;
+
+//! Read & Write tool for OrientedJoint
+class RWStepKinematics_RWOrientedJoint
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWOrientedJoint();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_OrientedJoint)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_OrientedJoint)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_OrientedJoint)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWOrientedJoint_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWPairRepresentationRelationship.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PairRepresentationRelationship.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_Representation.hxx>
+#include <StepRepr_RepresentationRelationshipWithTransformation.hxx>
+#include <StepRepr_RepresentationOrRepresentationReference.hxx>
+#include <StepRepr_Transformation.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPairRepresentationRelationship
+//purpose :
+//=======================================================================
+RWStepKinematics_RWPairRepresentationRelationship::RWStepKinematics_RWPairRepresentationRelationship() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPairRepresentationRelationship::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_PairRepresentationRelationship)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,6,theArch,"pair_representation_relationship") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of RepresentationRelationship
+
+ Handle(TCollection_HAsciiString) aRepresentationRelationship_Name;
+ theData->ReadString (theNum, 2, "representation_relationship.name", theArch, aRepresentationRelationship_Name);
+
+ Handle(TCollection_HAsciiString) aRepresentationRelationship_Description;
+ Standard_Boolean hasRepresentationRelationship_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "representation_relationship.description", theArch, aRepresentationRelationship_Description);
+ }
+ else {
+ hasRepresentationRelationship_Description = Standard_False;
+ aRepresentationRelationship_Description.Nullify();
+ }
+
+ StepRepr_RepresentationOrRepresentationReference aRepresentationRelationship_Rep1;
+ theData->ReadEntity (theNum, 4, "representation_relationship.rep1", theArch, aRepresentationRelationship_Rep1);
+
+ StepRepr_RepresentationOrRepresentationReference aRepresentationRelationship_Rep2;
+ theData->ReadEntity (theNum, 5, "representation_relationship.rep2", theArch, aRepresentationRelationship_Rep2);
+
+ // Inherited fields of RepresentationRelationshipWithTransformation
+
+ StepRepr_Transformation aRepresentationRelationshipWithTransformation_TransformationOperator;
+ theData->ReadEntity (theNum, 6, "representation_relationship_with_transformation.transformation_operator", theArch, aRepresentationRelationshipWithTransformation_TransformationOperator);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aRepresentationRelationship_Name,
+ hasRepresentationRelationship_Description,
+ aRepresentationRelationship_Description,
+ aRepresentationRelationship_Rep1,
+ aRepresentationRelationship_Rep2,
+ aRepresentationRelationshipWithTransformation_TransformationOperator);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPairRepresentationRelationship::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_PairRepresentationRelationship)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Own fields of RepresentationRelationship
+
+ theSW.Send (theEnt->Name());
+
+
+ if (theEnt->RepresentationRelationshipWithTransformation()->HasDescription())
+ theSW.Send (theEnt->RepresentationRelationshipWithTransformation()->Description());
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->RepresentationRelationshipWithTransformation()->Rep1());
+
+ theSW.Send (theEnt->RepresentationRelationshipWithTransformation()->Rep2());
+
+ // Inherited fields of RepresentationRelationshipWithTransformation
+
+ theSW.Send (theEnt->RepresentationRelationshipWithTransformation()->TransformationOperator().Value());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPairRepresentationRelationship::Share (const Handle(StepKinematics_PairRepresentationRelationship)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of RepresentationRelationship
+
+ iter.AddItem (theEnt->RepresentationRelationshipWithTransformation()->Rep1());
+
+ iter.AddItem (theEnt->RepresentationRelationshipWithTransformation()->Rep2());
+
+ // Inherited fields of RepresentationRelationshipWithTransformation
+
+ iter.AddItem (theEnt->RepresentationRelationshipWithTransformation()->TransformationOperator().Value());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWPairRepresentationRelationship_HeaderFile_
+#define _RWStepKinematics_RWPairRepresentationRelationship_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PairRepresentationRelationship;
+
+//! Read & Write tool for PairRepresentationRelationship
+class RWStepKinematics_RWPairRepresentationRelationship
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWPairRepresentationRelationship();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PairRepresentationRelationship)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PairRepresentationRelationship)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PairRepresentationRelationship)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPairRepresentationRelationship_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWPlanarCurvePair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PlanarCurvePair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Curve.hxx>
+#include <Standard_Boolean.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPlanarCurvePair
+//purpose :
+//=======================================================================
+RWStepKinematics_RWPlanarCurvePair::RWStepKinematics_RWPlanarCurvePair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPlanarCurvePair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_PlanarCurvePair)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,9,theArch,"planar_curve_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Own fields of PlanarCurvePair
+
+ Handle(StepGeom_Curve) aCurve1;
+ theData->ReadEntity (theNum, 7, "curve1", theArch, STANDARD_TYPE(StepGeom_Curve), aCurve1);
+
+ Handle(StepGeom_Curve) aCurve2;
+ theData->ReadEntity (theNum, 8, "curve2", theArch, STANDARD_TYPE(StepGeom_Curve), aCurve2);
+
+ Standard_Boolean aOrientation;
+ theData->ReadBoolean (theNum, 9, "orientation", theArch, aOrientation);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aCurve1,
+ aCurve2,
+ aOrientation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPlanarCurvePair::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_PlanarCurvePair)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of PlanarCurvePair
+
+ theSW.Send (theEnt->Curve1());
+
+ theSW.Send (theEnt->Curve2());
+
+ theSW.SendBoolean (theEnt->Orientation());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPlanarCurvePair::Share (const Handle(StepKinematics_PlanarCurvePair)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Own fields of PlanarCurvePair
+
+ iter.AddItem (theEnt->Curve1());
+
+ iter.AddItem (theEnt->Curve2());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWPlanarCurvePair_HeaderFile_
+#define _RWStepKinematics_RWPlanarCurvePair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PlanarCurvePair;
+
+//! Read & Write tool for PlanarCurvePair
+class RWStepKinematics_RWPlanarCurvePair
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWPlanarCurvePair();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PlanarCurvePair)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PlanarCurvePair)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PlanarCurvePair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPlanarCurvePair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWPlanarCurvePairRange.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PlanarCurvePairRange.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Curve.hxx>
+#include <Standard_Boolean.hxx>
+#include <StepGeom_TrimmedCurve.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPlanarCurvePairRange
+//purpose :
+//=======================================================================
+RWStepKinematics_RWPlanarCurvePairRange::RWStepKinematics_RWPlanarCurvePairRange() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPlanarCurvePairRange::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_PlanarCurvePairRange)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,11,theArch,"planar_curve_pair_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of PlanarCurvePair
+
+ Handle(StepGeom_Curve) aPlanarCurvePair_Curve1;
+ theData->ReadEntity (theNum, 7, "planar_curve_pair.curve1", theArch, STANDARD_TYPE(StepGeom_Curve), aPlanarCurvePair_Curve1);
+
+ Handle(StepGeom_Curve) aPlanarCurvePair_Curve2;
+ theData->ReadEntity (theNum, 8, "planar_curve_pair.curve2", theArch, STANDARD_TYPE(StepGeom_Curve), aPlanarCurvePair_Curve2);
+
+ Standard_Boolean aPlanarCurvePair_Orientation;
+ theData->ReadBoolean (theNum, 9, "planar_curve_pair.orientation", theArch, aPlanarCurvePair_Orientation);
+
+ // Own fields of PlanarCurvePairRange
+
+ Handle(StepGeom_TrimmedCurve) aRangeOnCurve1;
+ theData->ReadEntity (theNum, 10, "range_on_curve1", theArch, STANDARD_TYPE(StepGeom_TrimmedCurve), aRangeOnCurve1);
+
+ Handle(StepGeom_TrimmedCurve) aRangeOnCurve2;
+ theData->ReadEntity (theNum, 11, "range_on_curve2", theArch, STANDARD_TYPE(StepGeom_TrimmedCurve), aRangeOnCurve2);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aPlanarCurvePair_Curve1,
+ aPlanarCurvePair_Curve2,
+ aPlanarCurvePair_Orientation,
+ aRangeOnCurve1,
+ aRangeOnCurve2);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPlanarCurvePairRange::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_PlanarCurvePairRange)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of PlanarCurvePair
+
+ theSW.Send (theEnt->Curve1());
+
+ theSW.Send (theEnt->Curve2());
+
+ theSW.SendBoolean (theEnt->Orientation());
+
+ // Own fields of PlanarCurvePairRange
+
+ theSW.Send (theEnt->RangeOnCurve1());
+
+ theSW.Send (theEnt->RangeOnCurve2());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPlanarCurvePairRange::Share (const Handle(StepKinematics_PlanarCurvePairRange)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of PlanarCurvePair
+
+ iter.AddItem (theEnt->StepKinematics_PlanarCurvePair::Curve1());
+
+ iter.AddItem (theEnt->StepKinematics_PlanarCurvePair::Curve2());
+
+ // Own fields of PlanarCurvePairRange
+
+ iter.AddItem (theEnt->RangeOnCurve1());
+
+ iter.AddItem (theEnt->RangeOnCurve2());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWPlanarCurvePairRange_HeaderFile_
+#define _RWStepKinematics_RWPlanarCurvePairRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PlanarCurvePairRange;
+
+//! Read & Write tool for PlanarCurvePairRange
+class RWStepKinematics_RWPlanarCurvePairRange
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWPlanarCurvePairRange();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PlanarCurvePairRange)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PlanarCurvePairRange)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PlanarCurvePairRange)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPlanarCurvePairRange_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWPlanarPair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PlanarPair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPlanarPair
+//purpose :
+//=======================================================================
+RWStepKinematics_RWPlanarPair::RWStepKinematics_RWPlanarPair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPlanarPair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_PlanarPair)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,12,theArch,"planar_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPlanarPair::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_PlanarPair)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ theSW.SendBoolean (theEnt->TX());
+
+ theSW.SendBoolean (theEnt->TY());
+
+ theSW.SendBoolean (theEnt->TZ());
+
+ theSW.SendBoolean (theEnt->RX());
+
+ theSW.SendBoolean (theEnt->RY());
+
+ theSW.SendBoolean (theEnt->RZ());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPlanarPair::Share (const Handle(StepKinematics_PlanarPair)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWPlanarPair_HeaderFile_
+#define _RWStepKinematics_RWPlanarPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PlanarPair;
+
+//! Read & Write tool for PlanarPair
+class RWStepKinematics_RWPlanarPair
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWPlanarPair();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PlanarPair)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PlanarPair)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PlanarPair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPlanarPair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWPlanarPairValue.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PlanarPairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPlanarPairValue
+//purpose :
+//=======================================================================
+RWStepKinematics_RWPlanarPairValue::RWStepKinematics_RWPlanarPairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPlanarPairValue::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_PlanarPairValue)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,5,theArch,"planar_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Own fields of PlanarPairValue
+
+ Standard_Real aActualRotation;
+ theData->ReadReal (theNum, 3, "actual_rotation", theArch, aActualRotation);
+
+ Standard_Real aActualTranslationX;
+ theData->ReadReal (theNum, 4, "actual_translation_x", theArch, aActualTranslationX);
+
+ Standard_Real aActualTranslationY;
+ theData->ReadReal (theNum, 5, "actual_translation_y", theArch, aActualTranslationY);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair,
+ aActualRotation,
+ aActualTranslationX,
+ aActualTranslationY);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPlanarPairValue::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_PlanarPairValue)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Own fields of PairValue
+
+ theSW.Send (theEnt->AppliesToPair());
+
+ // Own fields of PlanarPairValue
+
+ theSW.Send (theEnt->ActualRotation());
+
+ theSW.Send (theEnt->ActualTranslationX());
+
+ theSW.Send (theEnt->ActualTranslationY());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPlanarPairValue::Share (const Handle(StepKinematics_PlanarPairValue)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair());
+
+ // Own fields of PlanarPairValue
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWPlanarPairValue_HeaderFile_
+#define _RWStepKinematics_RWPlanarPairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PlanarPairValue;
+
+//! Read & Write tool for PlanarPairValue
+class RWStepKinematics_RWPlanarPairValue
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWPlanarPairValue();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PlanarPairValue)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PlanarPairValue)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PlanarPairValue)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPlanarPairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWPlanarPairWithRange.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PlanarPairWithRange.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPlanarPairWithRange
+//purpose :
+//=======================================================================
+RWStepKinematics_RWPlanarPairWithRange::RWStepKinematics_RWPlanarPairWithRange() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPlanarPairWithRange::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_PlanarPairWithRange)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,18,theArch,"planar_pair_with_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ);
+
+ // Own fields of PlanarPairWithRange
+
+ Standard_Real aLowerLimitActualRotation;
+ Standard_Boolean hasLowerLimitActualRotation = Standard_True;
+ if ( theData->IsParamDefined (theNum,13) ) {
+ theData->ReadReal (theNum, 13, "lower_limit_actual_rotation", theArch, aLowerLimitActualRotation);
+ }
+ else {
+ hasLowerLimitActualRotation = Standard_False;
+ aLowerLimitActualRotation = 0;
+ }
+
+ Standard_Real aUpperLimitActualRotation;
+ Standard_Boolean hasUpperLimitActualRotation = Standard_True;
+ if ( theData->IsParamDefined (theNum,14) ) {
+ theData->ReadReal (theNum, 14, "upper_limit_actual_rotation", theArch, aUpperLimitActualRotation);
+ }
+ else {
+ hasUpperLimitActualRotation = Standard_False;
+ aUpperLimitActualRotation = 0;
+ }
+
+ Standard_Real aLowerLimitActualTranslationX;
+ Standard_Boolean hasLowerLimitActualTranslationX = Standard_True;
+ if ( theData->IsParamDefined (theNum,15) ) {
+ theData->ReadReal (theNum, 15, "lower_limit_actual_translation_x", theArch, aLowerLimitActualTranslationX);
+ }
+ else {
+ hasLowerLimitActualTranslationX = Standard_False;
+ aLowerLimitActualTranslationX = 0;
+ }
+
+ Standard_Real aUpperLimitActualTranslationX;
+ Standard_Boolean hasUpperLimitActualTranslationX = Standard_True;
+ if ( theData->IsParamDefined (theNum,16) ) {
+ theData->ReadReal (theNum, 16, "upper_limit_actual_translation_x", theArch, aUpperLimitActualTranslationX);
+ }
+ else {
+ hasUpperLimitActualTranslationX = Standard_False;
+ aUpperLimitActualTranslationX = 0;
+ }
+
+ Standard_Real aLowerLimitActualTranslationY;
+ Standard_Boolean hasLowerLimitActualTranslationY = Standard_True;
+ if ( theData->IsParamDefined (theNum,17) ) {
+ theData->ReadReal (theNum, 17, "lower_limit_actual_translation_y", theArch, aLowerLimitActualTranslationY);
+ }
+ else {
+ hasLowerLimitActualTranslationY = Standard_False;
+ aLowerLimitActualTranslationY = 0;
+ }
+
+ Standard_Real aUpperLimitActualTranslationY;
+ Standard_Boolean hasUpperLimitActualTranslationY = Standard_True;
+ if ( theData->IsParamDefined (theNum,18) ) {
+ theData->ReadReal (theNum, 18, "upper_limit_actual_translation_y", theArch, aUpperLimitActualTranslationY);
+ }
+ else {
+ hasUpperLimitActualTranslationY = Standard_False;
+ aUpperLimitActualTranslationY = 0;
+ }
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ,
+ hasLowerLimitActualRotation,
+ aLowerLimitActualRotation,
+ hasUpperLimitActualRotation,
+ aUpperLimitActualRotation,
+ hasLowerLimitActualTranslationX,
+ aLowerLimitActualTranslationX,
+ hasUpperLimitActualTranslationX,
+ aUpperLimitActualTranslationX,
+ hasLowerLimitActualTranslationY,
+ aLowerLimitActualTranslationY,
+ hasUpperLimitActualTranslationY,
+ aUpperLimitActualTranslationY);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPlanarPairWithRange::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_PlanarPairWithRange)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ theSW.SendBoolean (theEnt->TX());
+
+ theSW.SendBoolean (theEnt->TY());
+
+ theSW.SendBoolean (theEnt->TZ());
+
+ theSW.SendBoolean (theEnt->RX());
+
+ theSW.SendBoolean (theEnt->RY());
+
+ theSW.SendBoolean (theEnt->RZ());
+
+ // Own fields of PlanarPairWithRange
+
+ if ( theEnt->HasLowerLimitActualRotation() ) {
+ theSW.Send (theEnt->LowerLimitActualRotation());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitActualRotation() ) {
+ theSW.Send (theEnt->UpperLimitActualRotation());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasLowerLimitActualTranslationX() ) {
+ theSW.Send (theEnt->LowerLimitActualTranslationX());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitActualTranslationX() ) {
+ theSW.Send (theEnt->UpperLimitActualTranslationX());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasLowerLimitActualTranslationY() ) {
+ theSW.Send (theEnt->LowerLimitActualTranslationY());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitActualTranslationY() ) {
+ theSW.Send (theEnt->UpperLimitActualTranslationY());
+ }
+ else theSW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPlanarPairWithRange::Share (const Handle(StepKinematics_PlanarPairWithRange)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+
+ // Own fields of PlanarPairWithRange
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWPlanarPairWithRange_HeaderFile_
+#define _RWStepKinematics_RWPlanarPairWithRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PlanarPairWithRange;
+
+//! Read & Write tool for PlanarPairWithRange
+class RWStepKinematics_RWPlanarPairWithRange
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWPlanarPairWithRange();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PlanarPairWithRange)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PlanarPairWithRange)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PlanarPairWithRange)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPlanarPairWithRange_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWPointOnPlanarCurvePair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PointOnPlanarCurvePair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Curve.hxx>
+#include <Standard_Boolean.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPointOnPlanarCurvePair
+//purpose :
+//=======================================================================
+RWStepKinematics_RWPointOnPlanarCurvePair::RWStepKinematics_RWPointOnPlanarCurvePair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPointOnPlanarCurvePair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_PointOnPlanarCurvePair)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,8,theArch,"point_on_planar_curve_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Own fields of PointOnPlanarCurvePair
+
+ Handle(StepGeom_Curve) aPairCurve;
+ theData->ReadEntity (theNum, 7, "pair_curve", theArch, STANDARD_TYPE(StepGeom_Curve), aPairCurve);
+
+ Standard_Boolean aOrientation;
+ theData->ReadBoolean (theNum, 8, "orientation", theArch, aOrientation);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aPairCurve,
+ aOrientation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPointOnPlanarCurvePair::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_PointOnPlanarCurvePair)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of PointOnPlanarCurvePair
+
+ theSW.Send (theEnt->PairCurve());
+
+ theSW.SendBoolean (theEnt->Orientation());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPointOnPlanarCurvePair::Share (const Handle(StepKinematics_PointOnPlanarCurvePair)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Own fields of PointOnPlanarCurvePair
+
+ iter.AddItem (theEnt->PairCurve());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWPointOnPlanarCurvePair_HeaderFile_
+#define _RWStepKinematics_RWPointOnPlanarCurvePair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PointOnPlanarCurvePair;
+
+//! Read & Write tool for PointOnPlanarCurvePair
+class RWStepKinematics_RWPointOnPlanarCurvePair
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWPointOnPlanarCurvePair();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PointOnPlanarCurvePair)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PointOnPlanarCurvePair)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PointOnPlanarCurvePair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPointOnPlanarCurvePair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWPointOnPlanarCurvePairValue.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PointOnPlanarCurvePairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <StepGeom_PointOnCurve.hxx>
+#include <StepKinematics_SpatialRotation.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPointOnPlanarCurvePairValue
+//purpose :
+//=======================================================================
+RWStepKinematics_RWPointOnPlanarCurvePairValue::RWStepKinematics_RWPointOnPlanarCurvePairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPointOnPlanarCurvePairValue::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_PointOnPlanarCurvePairValue)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,4,theArch,"point_on_planar_curve_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Own fields of PointOnPlanarCurvePairValue
+
+ Handle(StepGeom_PointOnCurve) aActualPointOnCurve;
+ theData->ReadEntity (theNum, 3, "actual_point_on_curve", theArch, STANDARD_TYPE(StepGeom_PointOnCurve), aActualPointOnCurve);
+
+ StepKinematics_SpatialRotation aInputOrientation;
+ if (theData->SubListNumber(theNum, 4, Standard_True))
+ {
+ Handle(TColStd_HArray1OfReal) aItems;
+ Standard_Integer nsub = 0;
+ if (theData->ReadSubList(theNum, 4, "items", theArch, nsub)) {
+ Standard_Integer nb = theData->NbParams(nsub);
+ aItems = new TColStd_HArray1OfReal(1, nb);
+ Standard_Integer num2 = nsub;
+ for (Standard_Integer i0 = 1; i0 <= nb; i0++) {
+ Standard_Real anIt0;
+ theData->ReadReal(num2, i0, "real", theArch, anIt0);
+ aItems->SetValue(i0, anIt0);
+ }
+ }
+ aInputOrientation.SetValue(aItems);
+ }
+ else
+ theData->ReadEntity(theNum, 4, "input_orientation", theArch, aInputOrientation);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair,
+ aActualPointOnCurve,
+ aInputOrientation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPointOnPlanarCurvePairValue::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_PointOnPlanarCurvePairValue)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Own fields of PairValue
+
+ theSW.Send (theEnt->AppliesToPair());
+
+ // Own fields of PointOnPlanarCurvePairValue
+
+ theSW.Send (theEnt->ActualPointOnCurve());
+
+ if (!theEnt->InputOrientation().YprRotation().IsNull())
+ {
+ // Inherited field : YPR
+ theSW.OpenSub();
+ for (Standard_Integer i = 1; i <= theEnt->InputOrientation().YprRotation()->Length(); i++) {
+ theSW.Send(theEnt->InputOrientation().YprRotation()->Value(i));
+ }
+ theSW.CloseSub();
+ }
+ else
+ theSW.Send(theEnt->InputOrientation().Value());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPointOnPlanarCurvePairValue::Share (const Handle(StepKinematics_PointOnPlanarCurvePairValue)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair());
+
+ // Own fields of PointOnPlanarCurvePairValue
+
+ iter.AddItem (theEnt->ActualPointOnCurve());
+
+ if (!theEnt->InputOrientation().RotationAboutDirection().IsNull())
+ iter.AddItem(theEnt->InputOrientation().Value());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWPointOnPlanarCurvePairValue_HeaderFile_
+#define _RWStepKinematics_RWPointOnPlanarCurvePairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PointOnPlanarCurvePairValue;
+
+//! Read & Write tool for PointOnPlanarCurvePairValue
+class RWStepKinematics_RWPointOnPlanarCurvePairValue
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWPointOnPlanarCurvePairValue();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PointOnPlanarCurvePairValue)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PointOnPlanarCurvePairValue)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PointOnPlanarCurvePairValue)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPointOnPlanarCurvePairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWPointOnPlanarCurvePairWithRange.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PointOnPlanarCurvePairWithRange.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Curve.hxx>
+#include <Standard_Boolean.hxx>
+#include <StepGeom_TrimmedCurve.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPointOnPlanarCurvePairWithRange
+//purpose :
+//=======================================================================
+RWStepKinematics_RWPointOnPlanarCurvePairWithRange::RWStepKinematics_RWPointOnPlanarCurvePairWithRange() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPointOnPlanarCurvePairWithRange::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_PointOnPlanarCurvePairWithRange)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,15,theArch,"point_on_planar_curve_pair_with_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of PointOnPlanarCurvePair
+
+ Handle(StepGeom_Curve) aPointOnPlanarCurvePair_PairCurve;
+ theData->ReadEntity (theNum, 7, "point_on_planar_curve_pair.pair_curve", theArch, STANDARD_TYPE(StepGeom_Curve), aPointOnPlanarCurvePair_PairCurve);
+
+ Standard_Boolean aPointOnPlanarCurvePair_Orientation;
+ theData->ReadBoolean (theNum, 8, "point_on_planar_curve_pair.orientation", theArch, aPointOnPlanarCurvePair_Orientation);
+
+ // Own fields of PointOnPlanarCurvePairWithRange
+
+ Handle(StepGeom_TrimmedCurve) aRangeOnPairCurve;
+ theData->ReadEntity (theNum, 9, "range_on_pair_curve", theArch, STANDARD_TYPE(StepGeom_TrimmedCurve), aRangeOnPairCurve);
+
+ Standard_Real aLowerLimitYaw;
+ Standard_Boolean hasLowerLimitYaw = Standard_True;
+ if ( theData->IsParamDefined (theNum,10) ) {
+ theData->ReadReal (theNum, 10, "lower_limit_yaw", theArch, aLowerLimitYaw);
+ }
+ else {
+ hasLowerLimitYaw = Standard_False;
+ aLowerLimitYaw = 0;
+ }
+
+ Standard_Real aUpperLimitYaw;
+ Standard_Boolean hasUpperLimitYaw = Standard_True;
+ if ( theData->IsParamDefined (theNum,11) ) {
+ theData->ReadReal (theNum, 11, "upper_limit_yaw", theArch, aUpperLimitYaw);
+ }
+ else {
+ hasUpperLimitYaw = Standard_False;
+ aUpperLimitYaw = 0;
+ }
+
+ Standard_Real aLowerLimitPitch;
+ Standard_Boolean hasLowerLimitPitch = Standard_True;
+ if ( theData->IsParamDefined (theNum,12) ) {
+ theData->ReadReal (theNum, 12, "lower_limit_pitch", theArch, aLowerLimitPitch);
+ }
+ else {
+ hasLowerLimitPitch = Standard_False;
+ aLowerLimitPitch = 0;
+ }
+
+ Standard_Real aUpperLimitPitch;
+ Standard_Boolean hasUpperLimitPitch = Standard_True;
+ if ( theData->IsParamDefined (theNum,13) ) {
+ theData->ReadReal (theNum, 13, "upper_limit_pitch", theArch, aUpperLimitPitch);
+ }
+ else {
+ hasUpperLimitPitch = Standard_False;
+ aUpperLimitPitch = 0;
+ }
+
+ Standard_Real aLowerLimitRoll;
+ Standard_Boolean hasLowerLimitRoll = Standard_True;
+ if ( theData->IsParamDefined (theNum,14) ) {
+ theData->ReadReal (theNum, 14, "lower_limit_roll", theArch, aLowerLimitRoll);
+ }
+ else {
+ hasLowerLimitRoll = Standard_False;
+ aLowerLimitRoll = 0;
+ }
+
+ Standard_Real aUpperLimitRoll;
+ Standard_Boolean hasUpperLimitRoll = Standard_True;
+ if ( theData->IsParamDefined (theNum,15) ) {
+ theData->ReadReal (theNum, 15, "upper_limit_roll", theArch, aUpperLimitRoll);
+ }
+ else {
+ hasUpperLimitRoll = Standard_False;
+ aUpperLimitRoll = 0;
+ }
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aPointOnPlanarCurvePair_PairCurve,
+ aPointOnPlanarCurvePair_Orientation,
+ aRangeOnPairCurve,
+ hasLowerLimitYaw,
+ aLowerLimitYaw,
+ hasUpperLimitYaw,
+ aUpperLimitYaw,
+ hasLowerLimitPitch,
+ aLowerLimitPitch,
+ hasUpperLimitPitch,
+ aUpperLimitPitch,
+ hasLowerLimitRoll,
+ aLowerLimitRoll,
+ hasUpperLimitRoll,
+ aUpperLimitRoll);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPointOnPlanarCurvePairWithRange::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_PointOnPlanarCurvePairWithRange)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of PointOnPlanarCurvePair
+
+ theSW.Send (theEnt->PairCurve());
+
+ theSW.SendBoolean (theEnt->Orientation());
+
+ // Own fields of PointOnPlanarCurvePairWithRange
+
+ theSW.Send (theEnt->RangeOnPairCurve());
+
+ if ( theEnt->HasLowerLimitYaw() ) {
+ theSW.Send (theEnt->LowerLimitYaw());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitYaw() ) {
+ theSW.Send (theEnt->UpperLimitYaw());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasLowerLimitPitch() ) {
+ theSW.Send (theEnt->LowerLimitPitch());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitPitch() ) {
+ theSW.Send (theEnt->UpperLimitPitch());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasLowerLimitRoll() ) {
+ theSW.Send (theEnt->LowerLimitRoll());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitRoll() ) {
+ theSW.Send (theEnt->UpperLimitRoll());
+ }
+ else theSW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPointOnPlanarCurvePairWithRange::Share (const Handle(StepKinematics_PointOnPlanarCurvePairWithRange)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of PointOnPlanarCurvePair
+
+ iter.AddItem (theEnt->StepKinematics_PointOnPlanarCurvePair::PairCurve());
+
+ // Own fields of PointOnPlanarCurvePairWithRange
+
+ iter.AddItem (theEnt->RangeOnPairCurve());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWPointOnPlanarCurvePairWithRange_HeaderFile_
+#define _RWStepKinematics_RWPointOnPlanarCurvePairWithRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PointOnPlanarCurvePairWithRange;
+
+//! Read & Write tool for PointOnPlanarCurvePairWithRange
+class RWStepKinematics_RWPointOnPlanarCurvePairWithRange
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWPointOnPlanarCurvePairWithRange();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PointOnPlanarCurvePairWithRange)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PointOnPlanarCurvePairWithRange)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PointOnPlanarCurvePairWithRange)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPointOnPlanarCurvePairWithRange_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWPointOnSurfacePair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PointOnSurfacePair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Surface.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPointOnSurfacePair
+//purpose :
+//=======================================================================
+RWStepKinematics_RWPointOnSurfacePair::RWStepKinematics_RWPointOnSurfacePair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPointOnSurfacePair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_PointOnSurfacePair)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,7,theArch,"point_on_surface_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Own fields of PointOnSurfacePair
+
+ Handle(StepGeom_Surface) aPairSurface;
+ theData->ReadEntity (theNum, 7, "pair_surface", theArch, STANDARD_TYPE(StepGeom_Surface), aPairSurface);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aPairSurface);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPointOnSurfacePair::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_PointOnSurfacePair)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of PointOnSurfacePair
+
+ theSW.Send (theEnt->PairSurface());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPointOnSurfacePair::Share (const Handle(StepKinematics_PointOnSurfacePair)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Own fields of PointOnSurfacePair
+
+ iter.AddItem (theEnt->PairSurface());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWPointOnSurfacePair_HeaderFile_
+#define _RWStepKinematics_RWPointOnSurfacePair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PointOnSurfacePair;
+
+//! Read & Write tool for PointOnSurfacePair
+class RWStepKinematics_RWPointOnSurfacePair
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWPointOnSurfacePair();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PointOnSurfacePair)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PointOnSurfacePair)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PointOnSurfacePair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPointOnSurfacePair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWPointOnSurfacePairValue.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PointOnSurfacePairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <StepGeom_PointOnSurface.hxx>
+#include <StepKinematics_SpatialRotation.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPointOnSurfacePairValue
+//purpose :
+//=======================================================================
+RWStepKinematics_RWPointOnSurfacePairValue::RWStepKinematics_RWPointOnSurfacePairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPointOnSurfacePairValue::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_PointOnSurfacePairValue)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,4,theArch,"point_on_surface_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Own fields of PointOnSurfacePairValue
+
+ Handle(StepGeom_PointOnSurface) aActualPointOnSurface;
+ theData->ReadEntity (theNum, 3, "actual_point_on_surface", theArch, STANDARD_TYPE(StepGeom_PointOnSurface), aActualPointOnSurface);
+
+ StepKinematics_SpatialRotation aInputOrientation;
+ if (theData->SubListNumber(theNum, 4, Standard_True))
+ {
+ Handle(TColStd_HArray1OfReal) aItems;
+ Standard_Integer nsub = 0;
+ if (theData->ReadSubList(theNum, 4, "items", theArch, nsub)) {
+ Standard_Integer nb = theData->NbParams(nsub);
+ aItems = new TColStd_HArray1OfReal(1, nb);
+ Standard_Integer num2 = nsub;
+ for (Standard_Integer i0 = 1; i0 <= nb; i0++) {
+ Standard_Real anIt0;
+ theData->ReadReal(num2, i0, "real", theArch, anIt0);
+ aItems->SetValue(i0, anIt0);
+ }
+ }
+ aInputOrientation.SetValue(aItems);
+ }
+ else
+ theData->ReadEntity(theNum, 4, "input_orientation", theArch, aInputOrientation);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair,
+ aActualPointOnSurface,
+ aInputOrientation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPointOnSurfacePairValue::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_PointOnSurfacePairValue)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Own fields of PairValue
+
+ theSW.Send (theEnt->AppliesToPair());
+
+ // Own fields of PointOnSurfacePairValue
+
+ theSW.Send (theEnt->ActualPointOnSurface());
+
+ if (!theEnt->InputOrientation().YprRotation().IsNull())
+ {
+ // Inherited field : YPR
+ theSW.OpenSub();
+ for (Standard_Integer i = 1; i <= theEnt->InputOrientation().YprRotation()->Length(); i++) {
+ theSW.Send(theEnt->InputOrientation().YprRotation()->Value(i));
+ }
+ theSW.CloseSub();
+ }
+ else
+ theSW.Send(theEnt->InputOrientation().Value());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPointOnSurfacePairValue::Share (const Handle(StepKinematics_PointOnSurfacePairValue)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair());
+
+ // Own fields of PointOnSurfacePairValue
+
+ iter.AddItem (theEnt->ActualPointOnSurface());
+
+ if (!theEnt->InputOrientation().RotationAboutDirection().IsNull())
+ iter.AddItem(theEnt->InputOrientation().Value());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWPointOnSurfacePairValue_HeaderFile_
+#define _RWStepKinematics_RWPointOnSurfacePairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PointOnSurfacePairValue;
+
+//! Read & Write tool for PointOnSurfacePairValue
+class RWStepKinematics_RWPointOnSurfacePairValue
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWPointOnSurfacePairValue();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PointOnSurfacePairValue)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PointOnSurfacePairValue)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PointOnSurfacePairValue)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPointOnSurfacePairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWPointOnSurfacePairWithRange.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PointOnSurfacePairWithRange.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Surface.hxx>
+#include <StepGeom_RectangularTrimmedSurface.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPointOnSurfacePairWithRange
+//purpose :
+//=======================================================================
+RWStepKinematics_RWPointOnSurfacePairWithRange::RWStepKinematics_RWPointOnSurfacePairWithRange() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPointOnSurfacePairWithRange::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_PointOnSurfacePairWithRange)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,14,theArch,"point_on_surface_pair_with_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of PointOnSurfacePair
+
+ Handle(StepGeom_Surface) aPointOnSurfacePair_PairSurface;
+ theData->ReadEntity (theNum, 7, "point_on_surface_pair.pair_surface", theArch, STANDARD_TYPE(StepGeom_Surface), aPointOnSurfacePair_PairSurface);
+
+ // Own fields of PointOnSurfacePairWithRange
+
+ Handle(StepGeom_RectangularTrimmedSurface) aRangeOnPairSurface;
+ theData->ReadEntity (theNum, 8, "range_on_pair_surface", theArch, STANDARD_TYPE(StepGeom_RectangularTrimmedSurface), aRangeOnPairSurface);
+
+ Standard_Real aLowerLimitYaw;
+ Standard_Boolean hasLowerLimitYaw = Standard_True;
+ if ( theData->IsParamDefined (theNum,9) ) {
+ theData->ReadReal (theNum, 9, "lower_limit_yaw", theArch, aLowerLimitYaw);
+ }
+ else {
+ hasLowerLimitYaw = Standard_False;
+ aLowerLimitYaw = 0;
+ }
+
+ Standard_Real aUpperLimitYaw;
+ Standard_Boolean hasUpperLimitYaw = Standard_True;
+ if ( theData->IsParamDefined (theNum,10) ) {
+ theData->ReadReal (theNum, 10, "upper_limit_yaw", theArch, aUpperLimitYaw);
+ }
+ else {
+ hasUpperLimitYaw = Standard_False;
+ aUpperLimitYaw = 0;
+ }
+
+ Standard_Real aLowerLimitPitch;
+ Standard_Boolean hasLowerLimitPitch = Standard_True;
+ if ( theData->IsParamDefined (theNum,11) ) {
+ theData->ReadReal (theNum, 11, "lower_limit_pitch", theArch, aLowerLimitPitch);
+ }
+ else {
+ hasLowerLimitPitch = Standard_False;
+ aLowerLimitPitch = 0;
+ }
+
+ Standard_Real aUpperLimitPitch;
+ Standard_Boolean hasUpperLimitPitch = Standard_True;
+ if ( theData->IsParamDefined (theNum,12) ) {
+ theData->ReadReal (theNum, 12, "upper_limit_pitch", theArch, aUpperLimitPitch);
+ }
+ else {
+ hasUpperLimitPitch = Standard_False;
+ aUpperLimitPitch = 0;
+ }
+
+ Standard_Real aLowerLimitRoll;
+ Standard_Boolean hasLowerLimitRoll = Standard_True;
+ if ( theData->IsParamDefined (theNum,13) ) {
+ theData->ReadReal (theNum, 13, "lower_limit_roll", theArch, aLowerLimitRoll);
+ }
+ else {
+ hasLowerLimitRoll = Standard_False;
+ aLowerLimitRoll = 0;
+ }
+
+ Standard_Real aUpperLimitRoll;
+ Standard_Boolean hasUpperLimitRoll = Standard_True;
+ if ( theData->IsParamDefined (theNum,14) ) {
+ theData->ReadReal (theNum, 14, "upper_limit_roll", theArch, aUpperLimitRoll);
+ }
+ else {
+ hasUpperLimitRoll = Standard_False;
+ aUpperLimitRoll = 0;
+ }
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aPointOnSurfacePair_PairSurface,
+ aRangeOnPairSurface,
+ hasLowerLimitYaw,
+ aLowerLimitYaw,
+ hasUpperLimitYaw,
+ aUpperLimitYaw,
+ hasLowerLimitPitch,
+ aLowerLimitPitch,
+ hasUpperLimitPitch,
+ aUpperLimitPitch,
+ hasLowerLimitRoll,
+ aLowerLimitRoll,
+ hasUpperLimitRoll,
+ aUpperLimitRoll);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPointOnSurfacePairWithRange::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_PointOnSurfacePairWithRange)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of PointOnSurfacePair
+
+ theSW.Send (theEnt->PairSurface());
+
+ // Own fields of PointOnSurfacePairWithRange
+
+ theSW.Send (theEnt->RangeOnPairSurface());
+
+ if ( theEnt->HasLowerLimitYaw() ) {
+ theSW.Send (theEnt->LowerLimitYaw());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitYaw() ) {
+ theSW.Send (theEnt->UpperLimitYaw());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasLowerLimitPitch() ) {
+ theSW.Send (theEnt->LowerLimitPitch());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitPitch() ) {
+ theSW.Send (theEnt->UpperLimitPitch());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasLowerLimitRoll() ) {
+ theSW.Send (theEnt->LowerLimitRoll());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitRoll() ) {
+ theSW.Send (theEnt->UpperLimitRoll());
+ }
+ else theSW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPointOnSurfacePairWithRange::Share (const Handle(StepKinematics_PointOnSurfacePairWithRange)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of PointOnSurfacePair
+
+ iter.AddItem (theEnt->StepKinematics_PointOnSurfacePair::PairSurface());
+
+ // Own fields of PointOnSurfacePairWithRange
+
+ iter.AddItem (theEnt->RangeOnPairSurface());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWPointOnSurfacePairWithRange_HeaderFile_
+#define _RWStepKinematics_RWPointOnSurfacePairWithRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PointOnSurfacePairWithRange;
+
+//! Read & Write tool for PointOnSurfacePairWithRange
+class RWStepKinematics_RWPointOnSurfacePairWithRange
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWPointOnSurfacePairWithRange();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PointOnSurfacePairWithRange)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PointOnSurfacePairWithRange)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PointOnSurfacePairWithRange)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPointOnSurfacePairWithRange_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWPrismaticPair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PrismaticPair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPrismaticPair
+//purpose :
+//=======================================================================
+RWStepKinematics_RWPrismaticPair::RWStepKinematics_RWPrismaticPair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPrismaticPair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_PrismaticPair)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,12,theArch,"prismatic_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPrismaticPair::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_PrismaticPair)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ theSW.SendBoolean (theEnt->TX());
+
+ theSW.SendBoolean (theEnt->TY());
+
+ theSW.SendBoolean (theEnt->TZ());
+
+ theSW.SendBoolean (theEnt->RX());
+
+ theSW.SendBoolean (theEnt->RY());
+
+ theSW.SendBoolean (theEnt->RZ());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPrismaticPair::Share (const Handle(StepKinematics_PrismaticPair)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWPrismaticPair_HeaderFile_
+#define _RWStepKinematics_RWPrismaticPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PrismaticPair;
+
+//! Read & Write tool for PrismaticPair
+class RWStepKinematics_RWPrismaticPair
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWPrismaticPair();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PrismaticPair)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PrismaticPair)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PrismaticPair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPrismaticPair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWPrismaticPairValue.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PrismaticPairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPrismaticPairValue
+//purpose :
+//=======================================================================
+RWStepKinematics_RWPrismaticPairValue::RWStepKinematics_RWPrismaticPairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPrismaticPairValue::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_PrismaticPairValue)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,3,theArch,"prismatic_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Own fields of PrismaticPairValue
+
+ Standard_Real aActualTranslation;
+ theData->ReadReal (theNum, 3, "actual_translation", theArch, aActualTranslation);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair,
+ aActualTranslation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPrismaticPairValue::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_PrismaticPairValue)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Own fields of PairValue
+
+ theSW.Send (theEnt->AppliesToPair());
+
+ // Own fields of PrismaticPairValue
+
+ theSW.Send (theEnt->ActualTranslation());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPrismaticPairValue::Share (const Handle(StepKinematics_PrismaticPairValue)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair());
+
+ // Own fields of PrismaticPairValue
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWPrismaticPairValue_HeaderFile_
+#define _RWStepKinematics_RWPrismaticPairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PrismaticPairValue;
+
+//! Read & Write tool for PrismaticPairValue
+class RWStepKinematics_RWPrismaticPairValue
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWPrismaticPairValue();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PrismaticPairValue)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PrismaticPairValue)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PrismaticPairValue)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPrismaticPairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWPrismaticPairWithRange.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PrismaticPairWithRange.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPrismaticPairWithRange
+//purpose :
+//=======================================================================
+RWStepKinematics_RWPrismaticPairWithRange::RWStepKinematics_RWPrismaticPairWithRange() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPrismaticPairWithRange::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_PrismaticPairWithRange)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,14,theArch,"prismatic_pair_with_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ);
+
+ // Own fields of PrismaticPairWithRange
+
+ Standard_Real aLowerLimitActualTranslation;
+ Standard_Boolean hasLowerLimitActualTranslation = Standard_True;
+ if ( theData->IsParamDefined (theNum,13) ) {
+ theData->ReadReal (theNum, 13, "lower_limit_actual_translation", theArch, aLowerLimitActualTranslation);
+ }
+ else {
+ hasLowerLimitActualTranslation = Standard_False;
+ aLowerLimitActualTranslation = 0;
+ }
+
+ Standard_Real aUpperLimitActualTranslation;
+ Standard_Boolean hasUpperLimitActualTranslation = Standard_True;
+ if ( theData->IsParamDefined (theNum,14) ) {
+ theData->ReadReal (theNum, 14, "upper_limit_actual_translation", theArch, aUpperLimitActualTranslation);
+ }
+ else {
+ hasUpperLimitActualTranslation = Standard_False;
+ aUpperLimitActualTranslation = 0;
+ }
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ,
+ hasLowerLimitActualTranslation,
+ aLowerLimitActualTranslation,
+ hasUpperLimitActualTranslation,
+ aUpperLimitActualTranslation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPrismaticPairWithRange::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_PrismaticPairWithRange)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ theSW.SendBoolean (theEnt->TX());
+
+ theSW.SendBoolean (theEnt->TY());
+
+ theSW.SendBoolean (theEnt->TZ());
+
+ theSW.SendBoolean (theEnt->RX());
+
+ theSW.SendBoolean (theEnt->RY());
+
+ theSW.SendBoolean (theEnt->RZ());
+
+ // Own fields of PrismaticPairWithRange
+
+ if ( theEnt->HasLowerLimitActualTranslation() ) {
+ theSW.Send (theEnt->LowerLimitActualTranslation());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitActualTranslation() ) {
+ theSW.Send (theEnt->UpperLimitActualTranslation());
+ }
+ else theSW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWPrismaticPairWithRange::Share (const Handle(StepKinematics_PrismaticPairWithRange)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+
+ // Own fields of PrismaticPairWithRange
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWPrismaticPairWithRange_HeaderFile_
+#define _RWStepKinematics_RWPrismaticPairWithRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PrismaticPairWithRange;
+
+//! Read & Write tool for PrismaticPairWithRange
+class RWStepKinematics_RWPrismaticPairWithRange
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWPrismaticPairWithRange();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PrismaticPairWithRange)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PrismaticPairWithRange)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PrismaticPairWithRange)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPrismaticPairWithRange_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWProductDefinitionKinematics.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_ProductDefinitionKinematics.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_CharacterizedDefinition.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWProductDefinitionKinematics
+//purpose :
+//=======================================================================
+RWStepKinematics_RWProductDefinitionKinematics::RWStepKinematics_RWProductDefinitionKinematics() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWProductDefinitionKinematics::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_ProductDefinitionKinematics)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,3,theArch,"product_definition_kinematics") ) return;
+
+ // Inherited fields of PropertyDefinition
+
+ Handle(TCollection_HAsciiString) aPropertyDefinition_Name;
+ theData->ReadString (theNum, 1, "property_definition.name", theArch, aPropertyDefinition_Name);
+
+ Handle(TCollection_HAsciiString) aPropertyDefinition_Description;
+ Standard_Boolean hasPropertyDefinition_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,2) ) {
+ theData->ReadString (theNum, 2, "property_definition.description", theArch, aPropertyDefinition_Description);
+ }
+ else {
+ hasPropertyDefinition_Description = Standard_False;
+ aPropertyDefinition_Description.Nullify();
+ }
+
+ StepRepr_CharacterizedDefinition aPropertyDefinition_Definition;
+ theData->ReadEntity (theNum, 3, "property_definition.definition", theArch, aPropertyDefinition_Definition);
+
+ // Initialize entity
+ theEnt->Init(aPropertyDefinition_Name,
+ hasPropertyDefinition_Description,
+ aPropertyDefinition_Description,
+ aPropertyDefinition_Definition);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWProductDefinitionKinematics::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_ProductDefinitionKinematics)& theEnt) const
+{
+
+ // Own fields of PropertyDefinition
+
+ theSW.Send (theEnt->Name());
+
+ if ( theEnt->HasDescription() ) {
+ theSW.Send (theEnt->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->Definition().Value());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWProductDefinitionKinematics::Share (const Handle(StepKinematics_ProductDefinitionKinematics)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of PropertyDefinition
+
+ iter.AddItem (theEnt->StepRepr_PropertyDefinition::Definition().Value());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWProductDefinitionKinematics_HeaderFile_
+#define _RWStepKinematics_RWProductDefinitionKinematics_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_ProductDefinitionKinematics;
+
+//! Read & Write tool for ProductDefinitionKinematics
+class RWStepKinematics_RWProductDefinitionKinematics
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWProductDefinitionKinematics();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_ProductDefinitionKinematics)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_ProductDefinitionKinematics)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_ProductDefinitionKinematics)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWProductDefinitionKinematics_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWProductDefinitionRelationshipKinematics.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_ProductDefinitionRelationshipKinematics.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_CharacterizedDefinition.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWProductDefinitionRelationshipKinematics
+//purpose :
+//=======================================================================
+RWStepKinematics_RWProductDefinitionRelationshipKinematics::RWStepKinematics_RWProductDefinitionRelationshipKinematics() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWProductDefinitionRelationshipKinematics::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_ProductDefinitionRelationshipKinematics)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,3,theArch,"product_definition_relationship_kinematics") ) return;
+
+ // Inherited fields of PropertyDefinition
+
+ Handle(TCollection_HAsciiString) aPropertyDefinition_Name;
+ theData->ReadString (theNum, 1, "property_definition.name", theArch, aPropertyDefinition_Name);
+
+ Handle(TCollection_HAsciiString) aPropertyDefinition_Description;
+ Standard_Boolean hasPropertyDefinition_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,2) ) {
+ theData->ReadString (theNum, 2, "property_definition.description", theArch, aPropertyDefinition_Description);
+ }
+ else {
+ hasPropertyDefinition_Description = Standard_False;
+ aPropertyDefinition_Description.Nullify();
+ }
+
+ StepRepr_CharacterizedDefinition aPropertyDefinition_Definition;
+ theData->ReadEntity (theNum, 3, "property_definition.definition", theArch, aPropertyDefinition_Definition);
+
+ // Initialize entity
+ theEnt->Init(aPropertyDefinition_Name,
+ hasPropertyDefinition_Description,
+ aPropertyDefinition_Description,
+ aPropertyDefinition_Definition);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWProductDefinitionRelationshipKinematics::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_ProductDefinitionRelationshipKinematics)& theEnt) const
+{
+
+ // Own fields of PropertyDefinition
+
+ theSW.Send (theEnt->Name());
+
+ if ( theEnt->HasDescription() ) {
+ theSW.Send (theEnt->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->Definition().Value());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWProductDefinitionRelationshipKinematics::Share (const Handle(StepKinematics_ProductDefinitionRelationshipKinematics)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of PropertyDefinition
+
+ iter.AddItem (theEnt->StepRepr_PropertyDefinition::Definition().Value());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWProductDefinitionRelationshipKinematics_HeaderFile_
+#define _RWStepKinematics_RWProductDefinitionRelationshipKinematics_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_ProductDefinitionRelationshipKinematics;
+
+//! Read & Write tool for ProductDefinitionRelationshipKinematics
+class RWStepKinematics_RWProductDefinitionRelationshipKinematics
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWProductDefinitionRelationshipKinematics();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_ProductDefinitionRelationshipKinematics)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_ProductDefinitionRelationshipKinematics)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_ProductDefinitionRelationshipKinematics)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWProductDefinitionRelationshipKinematics_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWRackAndPinionPair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_RackAndPinionPair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWRackAndPinionPair
+//purpose :
+//=======================================================================
+RWStepKinematics_RWRackAndPinionPair::RWStepKinematics_RWRackAndPinionPair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRackAndPinionPair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_RackAndPinionPair)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,7,theArch,"rack_and_pinion_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Own fields of RackAndPinionPair
+
+ Standard_Real aPinionRadius;
+ theData->ReadReal (theNum, 7, "pinion_radius", theArch, aPinionRadius);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aPinionRadius);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRackAndPinionPair::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_RackAndPinionPair)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of RackAndPinionPair
+
+ theSW.Send (theEnt->PinionRadius());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRackAndPinionPair::Share (const Handle(StepKinematics_RackAndPinionPair)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Own fields of RackAndPinionPair
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWRackAndPinionPair_HeaderFile_
+#define _RWStepKinematics_RWRackAndPinionPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_RackAndPinionPair;
+
+//! Read & Write tool for RackAndPinionPair
+class RWStepKinematics_RWRackAndPinionPair
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWRackAndPinionPair();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_RackAndPinionPair)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_RackAndPinionPair)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_RackAndPinionPair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWRackAndPinionPair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWRackAndPinionPairValue.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_RackAndPinionPairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWRackAndPinionPairValue
+//purpose :
+//=======================================================================
+RWStepKinematics_RWRackAndPinionPairValue::RWStepKinematics_RWRackAndPinionPairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRackAndPinionPairValue::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_RackAndPinionPairValue)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,3,theArch,"rack_and_pinion_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Own fields of RackAndPinionPairValue
+
+ Standard_Real aActualDisplacement;
+ theData->ReadReal (theNum, 3, "actual_displacement", theArch, aActualDisplacement);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair,
+ aActualDisplacement);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRackAndPinionPairValue::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_RackAndPinionPairValue)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Own fields of PairValue
+
+ theSW.Send (theEnt->AppliesToPair());
+
+ // Own fields of RackAndPinionPairValue
+
+ theSW.Send (theEnt->ActualDisplacement());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRackAndPinionPairValue::Share (const Handle(StepKinematics_RackAndPinionPairValue)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair());
+
+ // Own fields of RackAndPinionPairValue
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWRackAndPinionPairValue_HeaderFile_
+#define _RWStepKinematics_RWRackAndPinionPairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_RackAndPinionPairValue;
+
+//! Read & Write tool for RackAndPinionPairValue
+class RWStepKinematics_RWRackAndPinionPairValue
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWRackAndPinionPairValue();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_RackAndPinionPairValue)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_RackAndPinionPairValue)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_RackAndPinionPairValue)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWRackAndPinionPairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWRackAndPinionPairWithRange.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_RackAndPinionPairWithRange.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWRackAndPinionPairWithRange
+//purpose :
+//=======================================================================
+RWStepKinematics_RWRackAndPinionPairWithRange::RWStepKinematics_RWRackAndPinionPairWithRange() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRackAndPinionPairWithRange::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_RackAndPinionPairWithRange)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,9,theArch,"rack_and_pinion_pair_with_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of RackAndPinionPair
+
+ Standard_Real aRackAndPinionPair_PinionRadius;
+ theData->ReadReal (theNum, 7, "rack_and_pinion_pair.pinion_radius", theArch, aRackAndPinionPair_PinionRadius);
+
+ // Own fields of RackAndPinionPairWithRange
+
+ Standard_Real aLowerLimitRackDisplacement;
+ Standard_Boolean hasLowerLimitRackDisplacement = Standard_True;
+ if ( theData->IsParamDefined (theNum,8) ) {
+ theData->ReadReal (theNum, 8, "lower_limit_rack_displacement", theArch, aLowerLimitRackDisplacement);
+ }
+ else {
+ hasLowerLimitRackDisplacement = Standard_False;
+ aLowerLimitRackDisplacement = 0;
+ }
+
+ Standard_Real aUpperLimitRackDisplacement;
+ Standard_Boolean hasUpperLimitRackDisplacement = Standard_True;
+ if ( theData->IsParamDefined (theNum,9) ) {
+ theData->ReadReal (theNum, 9, "upper_limit_rack_displacement", theArch, aUpperLimitRackDisplacement);
+ }
+ else {
+ hasUpperLimitRackDisplacement = Standard_False;
+ aUpperLimitRackDisplacement = 0;
+ }
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aRackAndPinionPair_PinionRadius,
+ hasLowerLimitRackDisplacement,
+ aLowerLimitRackDisplacement,
+ hasUpperLimitRackDisplacement,
+ aUpperLimitRackDisplacement);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRackAndPinionPairWithRange::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_RackAndPinionPairWithRange)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of RackAndPinionPair
+
+ theSW.Send (theEnt->PinionRadius());
+
+ // Own fields of RackAndPinionPairWithRange
+
+ if ( theEnt->HasLowerLimitRackDisplacement() ) {
+ theSW.Send (theEnt->LowerLimitRackDisplacement());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitRackDisplacement() ) {
+ theSW.Send (theEnt->UpperLimitRackDisplacement());
+ }
+ else theSW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRackAndPinionPairWithRange::Share (const Handle(StepKinematics_RackAndPinionPairWithRange)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of RackAndPinionPair
+
+ // Own fields of RackAndPinionPairWithRange
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWRackAndPinionPairWithRange_HeaderFile_
+#define _RWStepKinematics_RWRackAndPinionPairWithRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_RackAndPinionPairWithRange;
+
+//! Read & Write tool for RackAndPinionPairWithRange
+class RWStepKinematics_RWRackAndPinionPairWithRange
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWRackAndPinionPairWithRange();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_RackAndPinionPairWithRange)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_RackAndPinionPairWithRange)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_RackAndPinionPairWithRange)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWRackAndPinionPairWithRange_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWRevolutePair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_RevolutePair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWRevolutePair
+//purpose :
+//=======================================================================
+RWStepKinematics_RWRevolutePair::RWStepKinematics_RWRevolutePair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRevolutePair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_RevolutePair)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,12,theArch,"revolute_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRevolutePair::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_RevolutePair)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ theSW.SendBoolean (theEnt->TX());
+
+ theSW.SendBoolean (theEnt->TY());
+
+ theSW.SendBoolean (theEnt->TZ());
+
+ theSW.SendBoolean (theEnt->RX());
+
+ theSW.SendBoolean (theEnt->RY());
+
+ theSW.SendBoolean (theEnt->RZ());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRevolutePair::Share (const Handle(StepKinematics_RevolutePair)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWRevolutePair_HeaderFile_
+#define _RWStepKinematics_RWRevolutePair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_RevolutePair;
+
+//! Read & Write tool for RevolutePair
+class RWStepKinematics_RWRevolutePair
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWRevolutePair();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_RevolutePair)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_RevolutePair)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_RevolutePair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWRevolutePair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWRevolutePairValue.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_RevolutePairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWRevolutePairValue
+//purpose :
+//=======================================================================
+RWStepKinematics_RWRevolutePairValue::RWStepKinematics_RWRevolutePairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRevolutePairValue::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_RevolutePairValue)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,3,theArch,"revolute_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Own fields of RevolutePairValue
+
+ Standard_Real aActualRotation;
+ theData->ReadReal (theNum, 3, "actual_rotation", theArch, aActualRotation);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair,
+ aActualRotation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRevolutePairValue::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_RevolutePairValue)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Own fields of PairValue
+
+ theSW.Send (theEnt->AppliesToPair());
+
+ // Own fields of RevolutePairValue
+
+ theSW.Send (theEnt->ActualRotation());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRevolutePairValue::Share (const Handle(StepKinematics_RevolutePairValue)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair());
+
+ // Own fields of RevolutePairValue
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWRevolutePairValue_HeaderFile_
+#define _RWStepKinematics_RWRevolutePairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_RevolutePairValue;
+
+//! Read & Write tool for RevolutePairValue
+class RWStepKinematics_RWRevolutePairValue
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWRevolutePairValue();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_RevolutePairValue)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_RevolutePairValue)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_RevolutePairValue)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWRevolutePairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWRevolutePairWithRange.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_RevolutePairWithRange.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWRevolutePairWithRange
+//purpose :
+//=======================================================================
+RWStepKinematics_RWRevolutePairWithRange::RWStepKinematics_RWRevolutePairWithRange() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRevolutePairWithRange::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_RevolutePairWithRange)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,14,theArch,"revolute_pair_with_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ);
+
+ // Own fields of RevolutePairWithRange
+
+ Standard_Real aLowerLimitActualRotation;
+ Standard_Boolean hasLowerLimitActualRotation = Standard_True;
+ if ( theData->IsParamDefined (theNum,13) ) {
+ theData->ReadReal (theNum, 13, "lower_limit_actual_rotation", theArch, aLowerLimitActualRotation);
+ }
+ else {
+ hasLowerLimitActualRotation = Standard_False;
+ aLowerLimitActualRotation = 0;
+ }
+
+ Standard_Real aUpperLimitActualRotation;
+ Standard_Boolean hasUpperLimitActualRotation = Standard_True;
+ if ( theData->IsParamDefined (theNum,14) ) {
+ theData->ReadReal (theNum, 14, "upper_limit_actual_rotation", theArch, aUpperLimitActualRotation);
+ }
+ else {
+ hasUpperLimitActualRotation = Standard_False;
+ aUpperLimitActualRotation = 0;
+ }
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ,
+ hasLowerLimitActualRotation,
+ aLowerLimitActualRotation,
+ hasUpperLimitActualRotation,
+ aUpperLimitActualRotation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRevolutePairWithRange::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_RevolutePairWithRange)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ theSW.SendBoolean (theEnt->TX());
+
+ theSW.SendBoolean (theEnt->TY());
+
+ theSW.SendBoolean (theEnt->TZ());
+
+ theSW.SendBoolean (theEnt->RX());
+
+ theSW.SendBoolean (theEnt->RY());
+
+ theSW.SendBoolean (theEnt->RZ());
+
+ // Own fields of RevolutePairWithRange
+
+ if ( theEnt->HasLowerLimitActualRotation() ) {
+ theSW.Send (theEnt->LowerLimitActualRotation());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitActualRotation() ) {
+ theSW.Send (theEnt->UpperLimitActualRotation());
+ }
+ else theSW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRevolutePairWithRange::Share (const Handle(StepKinematics_RevolutePairWithRange)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+
+ // Own fields of RevolutePairWithRange
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWRevolutePairWithRange_HeaderFile_
+#define _RWStepKinematics_RWRevolutePairWithRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_RevolutePairWithRange;
+
+//! Read & Write tool for RevolutePairWithRange
+class RWStepKinematics_RWRevolutePairWithRange
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWRevolutePairWithRange();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_RevolutePairWithRange)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_RevolutePairWithRange)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_RevolutePairWithRange)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWRevolutePairWithRange_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWRigidLinkRepresentation.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_RigidLinkRepresentation.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_RepresentationContext.hxx>
+#include <StepKinematics_KinematicLink.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWRigidLinkRepresentation
+//purpose :
+//=======================================================================
+RWStepKinematics_RWRigidLinkRepresentation::RWStepKinematics_RWRigidLinkRepresentation() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRigidLinkRepresentation::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_RigidLinkRepresentation)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,4,theArch,"rigid_link_representation") ) return;
+
+ // Inherited fields of Representation
+
+ Handle(TCollection_HAsciiString) aRepresentation_Name;
+ theData->ReadString (theNum, 1, "representation.name", theArch, aRepresentation_Name);
+
+ Handle(StepRepr_HArray1OfRepresentationItem) aRepresentation_Items;
+ Standard_Integer sub2 = 0;
+ if ( theData->ReadSubList (theNum, 2, "representation.items", theArch, sub2) ) {
+ Standard_Integer nb0 = theData->NbParams(sub2);
+ aRepresentation_Items = new StepRepr_HArray1OfRepresentationItem (1, nb0);
+ Standard_Integer num2 = sub2;
+ for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
+ Handle(StepRepr_RepresentationItem) anIt0;
+ theData->ReadEntity (num2, i0, "representation_item", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), anIt0);
+ aRepresentation_Items->SetValue(i0, anIt0);
+ }
+ }
+
+ Handle(StepRepr_RepresentationContext) aRepresentation_ContextOfItems;
+ theData->ReadEntity (theNum, 3, "representation.context_of_items", theArch, STANDARD_TYPE(StepRepr_RepresentationContext), aRepresentation_ContextOfItems);
+
+ // Inherited fields of KinematicLinkRepresentation
+
+ Handle(StepKinematics_KinematicLink) aKinematicLinkRepresentation_RepresentedLink;
+ theData->ReadEntity (theNum, 4, "kinematic_link_representation.represented_link", theArch, STANDARD_TYPE(StepKinematics_KinematicLink), aKinematicLinkRepresentation_RepresentedLink);
+
+ // Initialize entity
+ theEnt->Init(aRepresentation_Name,
+ aRepresentation_Items,
+ aRepresentation_ContextOfItems,
+ aKinematicLinkRepresentation_RepresentedLink);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRigidLinkRepresentation::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_RigidLinkRepresentation)& theEnt) const
+{
+
+ // Own fields of Representation
+
+ theSW.Send (theEnt->Name());
+
+ theSW.OpenSub();
+ for (Standard_Integer i1=1; i1 <= theEnt->Items()->Length(); i1++ ) {
+ Handle(StepRepr_RepresentationItem) Var0 = theEnt->Items()->Value(i1);
+ theSW.Send (Var0);
+ }
+ theSW.CloseSub();
+
+ theSW.Send (theEnt->ContextOfItems());
+
+ // Own fields of KinematicLinkRepresentation
+
+ theSW.Send (theEnt->RepresentedLink());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRigidLinkRepresentation::Share (const Handle(StepKinematics_RigidLinkRepresentation)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of Representation
+
+ for (Standard_Integer i1=1; i1 <= theEnt->StepRepr_Representation::Items()->Length(); i1++ ) {
+ Handle(StepRepr_RepresentationItem) Var0 = theEnt->StepRepr_Representation::Items()->Value(i1);
+ iter.AddItem (Var0);
+ }
+
+ iter.AddItem (theEnt->StepRepr_Representation::ContextOfItems());
+
+ // Inherited fields of KinematicLinkRepresentation
+
+ iter.AddItem (theEnt->StepKinematics_KinematicLinkRepresentation::RepresentedLink());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWRigidLinkRepresentation_HeaderFile_
+#define _RWStepKinematics_RWRigidLinkRepresentation_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_RigidLinkRepresentation;
+
+//! Read & Write tool for RigidLinkRepresentation
+class RWStepKinematics_RWRigidLinkRepresentation
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWRigidLinkRepresentation();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_RigidLinkRepresentation)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_RigidLinkRepresentation)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_RigidLinkRepresentation)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWRigidLinkRepresentation_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWRollingCurvePair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_RollingCurvePair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Curve.hxx>
+#include <Standard_Boolean.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWRollingCurvePair
+//purpose :
+//=======================================================================
+RWStepKinematics_RWRollingCurvePair::RWStepKinematics_RWRollingCurvePair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRollingCurvePair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_RollingCurvePair)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,9,theArch,"rolling_curve_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of PlanarCurvePair
+
+ Handle(StepGeom_Curve) aPlanarCurvePair_Curve1;
+ theData->ReadEntity (theNum, 7, "planar_curve_pair.curve1", theArch, STANDARD_TYPE(StepGeom_Curve), aPlanarCurvePair_Curve1);
+
+ Handle(StepGeom_Curve) aPlanarCurvePair_Curve2;
+ theData->ReadEntity (theNum, 8, "planar_curve_pair.curve2", theArch, STANDARD_TYPE(StepGeom_Curve), aPlanarCurvePair_Curve2);
+
+ Standard_Boolean aPlanarCurvePair_Orientation;
+ theData->ReadBoolean (theNum, 9, "planar_curve_pair.orientation", theArch, aPlanarCurvePair_Orientation);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aPlanarCurvePair_Curve1,
+ aPlanarCurvePair_Curve2,
+ aPlanarCurvePair_Orientation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRollingCurvePair::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_RollingCurvePair)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of PlanarCurvePair
+
+ theSW.Send (theEnt->Curve1());
+
+ theSW.Send (theEnt->Curve2());
+
+ theSW.SendBoolean (theEnt->Orientation());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRollingCurvePair::Share (const Handle(StepKinematics_RollingCurvePair)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of PlanarCurvePair
+
+ iter.AddItem (theEnt->StepKinematics_PlanarCurvePair::Curve1());
+
+ iter.AddItem (theEnt->StepKinematics_PlanarCurvePair::Curve2());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWRollingCurvePair_HeaderFile_
+#define _RWStepKinematics_RWRollingCurvePair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_RollingCurvePair;
+
+//! Read & Write tool for RollingCurvePair
+class RWStepKinematics_RWRollingCurvePair
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWRollingCurvePair();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_RollingCurvePair)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_RollingCurvePair)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_RollingCurvePair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWRollingCurvePair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWRollingCurvePairValue.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_RollingCurvePairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <StepGeom_PointOnCurve.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWRollingCurvePairValue
+//purpose :
+//=======================================================================
+RWStepKinematics_RWRollingCurvePairValue::RWStepKinematics_RWRollingCurvePairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRollingCurvePairValue::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_RollingCurvePairValue)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,3,theArch,"rolling_curve_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Own fields of RollingCurvePairValue
+
+ Handle(StepGeom_PointOnCurve) aActualPointOnCurve1;
+ theData->ReadEntity (theNum, 3, "actual_point_on_curve1", theArch, STANDARD_TYPE(StepGeom_PointOnCurve), aActualPointOnCurve1);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair,
+ aActualPointOnCurve1);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRollingCurvePairValue::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_RollingCurvePairValue)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Own fields of PairValue
+
+ theSW.Send (theEnt->AppliesToPair());
+
+ // Own fields of RollingCurvePairValue
+
+ theSW.Send (theEnt->ActualPointOnCurve1());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRollingCurvePairValue::Share (const Handle(StepKinematics_RollingCurvePairValue)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair());
+
+ // Own fields of RollingCurvePairValue
+
+ iter.AddItem (theEnt->ActualPointOnCurve1());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWRollingCurvePairValue_HeaderFile_
+#define _RWStepKinematics_RWRollingCurvePairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_RollingCurvePairValue;
+
+//! Read & Write tool for RollingCurvePairValue
+class RWStepKinematics_RWRollingCurvePairValue
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWRollingCurvePairValue();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_RollingCurvePairValue)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_RollingCurvePairValue)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_RollingCurvePairValue)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWRollingCurvePairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWRollingSurfacePair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_RollingSurfacePair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Surface.hxx>
+#include <Standard_Boolean.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWRollingSurfacePair
+//purpose :
+//=======================================================================
+RWStepKinematics_RWRollingSurfacePair::RWStepKinematics_RWRollingSurfacePair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRollingSurfacePair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_RollingSurfacePair)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,9,theArch,"rolling_surface_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of SurfacePair
+
+ Handle(StepGeom_Surface) aSurfacePair_Surface1;
+ theData->ReadEntity (theNum, 7, "surface_pair.surface1", theArch, STANDARD_TYPE(StepGeom_Surface), aSurfacePair_Surface1);
+
+ Handle(StepGeom_Surface) aSurfacePair_Surface2;
+ theData->ReadEntity (theNum, 8, "surface_pair.surface2", theArch, STANDARD_TYPE(StepGeom_Surface), aSurfacePair_Surface2);
+
+ Standard_Boolean aSurfacePair_Orientation;
+ theData->ReadBoolean (theNum, 9, "surface_pair.orientation", theArch, aSurfacePair_Orientation);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aSurfacePair_Surface1,
+ aSurfacePair_Surface2,
+ aSurfacePair_Orientation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRollingSurfacePair::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_RollingSurfacePair)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of SurfacePair
+
+ theSW.Send (theEnt->Surface1());
+
+ theSW.Send (theEnt->Surface2());
+
+ theSW.SendBoolean (theEnt->Orientation());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRollingSurfacePair::Share (const Handle(StepKinematics_RollingSurfacePair)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of SurfacePair
+
+ iter.AddItem (theEnt->StepKinematics_SurfacePair::Surface1());
+
+ iter.AddItem (theEnt->StepKinematics_SurfacePair::Surface2());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWRollingSurfacePair_HeaderFile_
+#define _RWStepKinematics_RWRollingSurfacePair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_RollingSurfacePair;
+
+//! Read & Write tool for RollingSurfacePair
+class RWStepKinematics_RWRollingSurfacePair
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWRollingSurfacePair();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_RollingSurfacePair)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_RollingSurfacePair)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_RollingSurfacePair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWRollingSurfacePair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWRollingSurfacePairValue.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_RollingSurfacePairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <StepGeom_PointOnSurface.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWRollingSurfacePairValue
+//purpose :
+//=======================================================================
+RWStepKinematics_RWRollingSurfacePairValue::RWStepKinematics_RWRollingSurfacePairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRollingSurfacePairValue::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_RollingSurfacePairValue)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,4,theArch,"rolling_surface_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Own fields of RollingSurfacePairValue
+
+ Handle(StepGeom_PointOnSurface) aActualPointOnSurface;
+ theData->ReadEntity (theNum, 3, "actual_point_on_surface", theArch, STANDARD_TYPE(StepGeom_PointOnSurface), aActualPointOnSurface);
+
+ Standard_Real aActualRotation;
+ theData->ReadReal (theNum, 4, "actual_rotation", theArch, aActualRotation);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair,
+ aActualPointOnSurface,
+ aActualRotation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRollingSurfacePairValue::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_RollingSurfacePairValue)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Own fields of PairValue
+
+ theSW.Send (theEnt->AppliesToPair());
+
+ // Own fields of RollingSurfacePairValue
+
+ theSW.Send (theEnt->ActualPointOnSurface());
+
+ theSW.Send (theEnt->ActualRotation());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRollingSurfacePairValue::Share (const Handle(StepKinematics_RollingSurfacePairValue)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair());
+
+ // Own fields of RollingSurfacePairValue
+
+ iter.AddItem (theEnt->ActualPointOnSurface());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWRollingSurfacePairValue_HeaderFile_
+#define _RWStepKinematics_RWRollingSurfacePairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_RollingSurfacePairValue;
+
+//! Read & Write tool for RollingSurfacePairValue
+class RWStepKinematics_RWRollingSurfacePairValue
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWRollingSurfacePairValue();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_RollingSurfacePairValue)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_RollingSurfacePairValue)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_RollingSurfacePairValue)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWRollingSurfacePairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:14 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWRotationAboutDirection.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_RotationAboutDirection.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepGeom_Direction.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWRotationAboutDirection
+//purpose :
+//=======================================================================
+RWStepKinematics_RWRotationAboutDirection::RWStepKinematics_RWRotationAboutDirection() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRotationAboutDirection::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_RotationAboutDirection)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,3,theArch,"rotation_about_direction") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Own fields of RotationAboutDirection
+
+ Handle(StepGeom_Direction) aDirectionOfAxis;
+ theData->ReadEntity (theNum, 2, "direction_of_axis", theArch, STANDARD_TYPE(StepGeom_Direction), aDirectionOfAxis);
+
+ Standard_Real aRotationAngle;
+ theData->ReadReal (theNum, 3, "rotation_angle", theArch, aRotationAngle);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aDirectionOfAxis,
+ aRotationAngle);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRotationAboutDirection::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_RotationAboutDirection)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Own fields of RotationAboutDirection
+
+ theSW.Send (theEnt->DirectionOfAxis());
+
+ theSW.Send (theEnt->RotationAngle());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWRotationAboutDirection::Share (const Handle(StepKinematics_RotationAboutDirection)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Own fields of RotationAboutDirection
+
+ iter.AddItem (theEnt->DirectionOfAxis());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:14 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWRotationAboutDirection_HeaderFile_
+#define _RWStepKinematics_RWRotationAboutDirection_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_RotationAboutDirection;
+
+//! Read & Write tool for RotationAboutDirection
+class RWStepKinematics_RWRotationAboutDirection
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWRotationAboutDirection();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_RotationAboutDirection)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_RotationAboutDirection)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_RotationAboutDirection)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWRotationAboutDirection_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWScrewPair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_ScrewPair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWScrewPair
+//purpose :
+//=======================================================================
+RWStepKinematics_RWScrewPair::RWStepKinematics_RWScrewPair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWScrewPair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_ScrewPair)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,7,theArch,"screw_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Own fields of ScrewPair
+
+ Standard_Real aPitch;
+ theData->ReadReal (theNum, 7, "pitch", theArch, aPitch);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aPitch);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWScrewPair::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_ScrewPair)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of ScrewPair
+
+ theSW.Send (theEnt->Pitch());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWScrewPair::Share (const Handle(StepKinematics_ScrewPair)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Own fields of ScrewPair
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWScrewPair_HeaderFile_
+#define _RWStepKinematics_RWScrewPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_ScrewPair;
+
+//! Read & Write tool for ScrewPair
+class RWStepKinematics_RWScrewPair
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWScrewPair();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_ScrewPair)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_ScrewPair)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_ScrewPair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWScrewPair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWScrewPairValue.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_ScrewPairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWScrewPairValue
+//purpose :
+//=======================================================================
+RWStepKinematics_RWScrewPairValue::RWStepKinematics_RWScrewPairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWScrewPairValue::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_ScrewPairValue)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,3,theArch,"screw_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Own fields of ScrewPairValue
+
+ Standard_Real aActualRotation;
+ theData->ReadReal (theNum, 3, "actual_rotation", theArch, aActualRotation);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair,
+ aActualRotation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWScrewPairValue::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_ScrewPairValue)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Own fields of PairValue
+
+ theSW.Send (theEnt->AppliesToPair());
+
+ // Own fields of ScrewPairValue
+
+ theSW.Send (theEnt->ActualRotation());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWScrewPairValue::Share (const Handle(StepKinematics_ScrewPairValue)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair());
+
+ // Own fields of ScrewPairValue
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWScrewPairValue_HeaderFile_
+#define _RWStepKinematics_RWScrewPairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_ScrewPairValue;
+
+//! Read & Write tool for ScrewPairValue
+class RWStepKinematics_RWScrewPairValue
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWScrewPairValue();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_ScrewPairValue)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_ScrewPairValue)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_ScrewPairValue)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWScrewPairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWScrewPairWithRange.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_ScrewPairWithRange.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWScrewPairWithRange
+//purpose :
+//=======================================================================
+RWStepKinematics_RWScrewPairWithRange::RWStepKinematics_RWScrewPairWithRange() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWScrewPairWithRange::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_ScrewPairWithRange)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,9,theArch,"screw_pair_with_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of ScrewPair
+
+ Standard_Real aScrewPair_Pitch;
+ theData->ReadReal (theNum, 7, "screw_pair.pitch", theArch, aScrewPair_Pitch);
+
+ // Own fields of ScrewPairWithRange
+
+ Standard_Real aLowerLimitActualRotation;
+ Standard_Boolean hasLowerLimitActualRotation = Standard_True;
+ if ( theData->IsParamDefined (theNum,8) ) {
+ theData->ReadReal (theNum, 8, "lower_limit_actual_rotation", theArch, aLowerLimitActualRotation);
+ }
+ else {
+ hasLowerLimitActualRotation = Standard_False;
+ aLowerLimitActualRotation = 0;
+ }
+
+ Standard_Real aUpperLimitActualRotation;
+ Standard_Boolean hasUpperLimitActualRotation = Standard_True;
+ if ( theData->IsParamDefined (theNum,9) ) {
+ theData->ReadReal (theNum, 9, "upper_limit_actual_rotation", theArch, aUpperLimitActualRotation);
+ }
+ else {
+ hasUpperLimitActualRotation = Standard_False;
+ aUpperLimitActualRotation = 0;
+ }
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aScrewPair_Pitch,
+ hasLowerLimitActualRotation,
+ aLowerLimitActualRotation,
+ hasUpperLimitActualRotation,
+ aUpperLimitActualRotation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWScrewPairWithRange::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_ScrewPairWithRange)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of ScrewPair
+
+ theSW.Send (theEnt->Pitch());
+
+ // Own fields of ScrewPairWithRange
+
+ if ( theEnt->HasLowerLimitActualRotation() ) {
+ theSW.Send (theEnt->LowerLimitActualRotation());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitActualRotation() ) {
+ theSW.Send (theEnt->UpperLimitActualRotation());
+ }
+ else theSW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWScrewPairWithRange::Share (const Handle(StepKinematics_ScrewPairWithRange)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of ScrewPair
+
+ // Own fields of ScrewPairWithRange
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWScrewPairWithRange_HeaderFile_
+#define _RWStepKinematics_RWScrewPairWithRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_ScrewPairWithRange;
+
+//! Read & Write tool for ScrewPairWithRange
+class RWStepKinematics_RWScrewPairWithRange
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWScrewPairWithRange();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_ScrewPairWithRange)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_ScrewPairWithRange)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_ScrewPairWithRange)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWScrewPairWithRange_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWSlidingCurvePair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_SlidingCurvePair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Curve.hxx>
+#include <Standard_Boolean.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWSlidingCurvePair
+//purpose :
+//=======================================================================
+RWStepKinematics_RWSlidingCurvePair::RWStepKinematics_RWSlidingCurvePair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSlidingCurvePair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_SlidingCurvePair)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,9,theArch,"sliding_curve_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of PlanarCurvePair
+
+ Handle(StepGeom_Curve) aPlanarCurvePair_Curve1;
+ theData->ReadEntity (theNum, 7, "planar_curve_pair.curve1", theArch, STANDARD_TYPE(StepGeom_Curve), aPlanarCurvePair_Curve1);
+
+ Handle(StepGeom_Curve) aPlanarCurvePair_Curve2;
+ theData->ReadEntity (theNum, 8, "planar_curve_pair.curve2", theArch, STANDARD_TYPE(StepGeom_Curve), aPlanarCurvePair_Curve2);
+
+ Standard_Boolean aPlanarCurvePair_Orientation;
+ theData->ReadBoolean (theNum, 9, "planar_curve_pair.orientation", theArch, aPlanarCurvePair_Orientation);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aPlanarCurvePair_Curve1,
+ aPlanarCurvePair_Curve2,
+ aPlanarCurvePair_Orientation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSlidingCurvePair::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_SlidingCurvePair)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of PlanarCurvePair
+
+ theSW.Send (theEnt->Curve1());
+
+ theSW.Send (theEnt->Curve2());
+
+ theSW.SendBoolean (theEnt->Orientation());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSlidingCurvePair::Share (const Handle(StepKinematics_SlidingCurvePair)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of PlanarCurvePair
+
+ iter.AddItem (theEnt->StepKinematics_PlanarCurvePair::Curve1());
+
+ iter.AddItem (theEnt->StepKinematics_PlanarCurvePair::Curve2());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWSlidingCurvePair_HeaderFile_
+#define _RWStepKinematics_RWSlidingCurvePair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_SlidingCurvePair;
+
+//! Read & Write tool for SlidingCurvePair
+class RWStepKinematics_RWSlidingCurvePair
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWSlidingCurvePair();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_SlidingCurvePair)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_SlidingCurvePair)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_SlidingCurvePair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWSlidingCurvePair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWSlidingCurvePairValue.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_SlidingCurvePairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <StepGeom_PointOnCurve.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWSlidingCurvePairValue
+//purpose :
+//=======================================================================
+RWStepKinematics_RWSlidingCurvePairValue::RWStepKinematics_RWSlidingCurvePairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSlidingCurvePairValue::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_SlidingCurvePairValue)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,4,theArch,"sliding_curve_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Own fields of SlidingCurvePairValue
+
+ Handle(StepGeom_PointOnCurve) aActualPointOnCurve1;
+ theData->ReadEntity (theNum, 3, "actual_point_on_curve1", theArch, STANDARD_TYPE(StepGeom_PointOnCurve), aActualPointOnCurve1);
+
+ Handle(StepGeom_PointOnCurve) aActualPointOnCurve2;
+ theData->ReadEntity (theNum, 4, "actual_point_on_curve2", theArch, STANDARD_TYPE(StepGeom_PointOnCurve), aActualPointOnCurve2);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair,
+ aActualPointOnCurve1,
+ aActualPointOnCurve2);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSlidingCurvePairValue::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_SlidingCurvePairValue)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Own fields of PairValue
+
+ theSW.Send (theEnt->AppliesToPair());
+
+ // Own fields of SlidingCurvePairValue
+
+ theSW.Send (theEnt->ActualPointOnCurve1());
+
+ theSW.Send (theEnt->ActualPointOnCurve2());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSlidingCurvePairValue::Share (const Handle(StepKinematics_SlidingCurvePairValue)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair());
+
+ // Own fields of SlidingCurvePairValue
+
+ iter.AddItem (theEnt->ActualPointOnCurve1());
+
+ iter.AddItem (theEnt->ActualPointOnCurve2());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWSlidingCurvePairValue_HeaderFile_
+#define _RWStepKinematics_RWSlidingCurvePairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_SlidingCurvePairValue;
+
+//! Read & Write tool for SlidingCurvePairValue
+class RWStepKinematics_RWSlidingCurvePairValue
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWSlidingCurvePairValue();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_SlidingCurvePairValue)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_SlidingCurvePairValue)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_SlidingCurvePairValue)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWSlidingCurvePairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWSlidingSurfacePair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_SlidingSurfacePair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Surface.hxx>
+#include <Standard_Boolean.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWSlidingSurfacePair
+//purpose :
+//=======================================================================
+RWStepKinematics_RWSlidingSurfacePair::RWStepKinematics_RWSlidingSurfacePair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSlidingSurfacePair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_SlidingSurfacePair)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,9,theArch,"sliding_surface_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of SurfacePair
+
+ Handle(StepGeom_Surface) aSurfacePair_Surface1;
+ theData->ReadEntity (theNum, 7, "surface_pair.surface1", theArch, STANDARD_TYPE(StepGeom_Surface), aSurfacePair_Surface1);
+
+ Handle(StepGeom_Surface) aSurfacePair_Surface2;
+ theData->ReadEntity (theNum, 8, "surface_pair.surface2", theArch, STANDARD_TYPE(StepGeom_Surface), aSurfacePair_Surface2);
+
+ Standard_Boolean aSurfacePair_Orientation;
+ theData->ReadBoolean (theNum, 9, "surface_pair.orientation", theArch, aSurfacePair_Orientation);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aSurfacePair_Surface1,
+ aSurfacePair_Surface2,
+ aSurfacePair_Orientation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSlidingSurfacePair::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_SlidingSurfacePair)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of SurfacePair
+
+ theSW.Send (theEnt->Surface1());
+
+ theSW.Send (theEnt->Surface2());
+
+ theSW.SendBoolean (theEnt->Orientation());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSlidingSurfacePair::Share (const Handle(StepKinematics_SlidingSurfacePair)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of SurfacePair
+
+ iter.AddItem (theEnt->StepKinematics_SurfacePair::Surface1());
+
+ iter.AddItem (theEnt->StepKinematics_SurfacePair::Surface2());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWSlidingSurfacePair_HeaderFile_
+#define _RWStepKinematics_RWSlidingSurfacePair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_SlidingSurfacePair;
+
+//! Read & Write tool for SlidingSurfacePair
+class RWStepKinematics_RWSlidingSurfacePair
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWSlidingSurfacePair();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_SlidingSurfacePair)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_SlidingSurfacePair)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_SlidingSurfacePair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWSlidingSurfacePair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWSlidingSurfacePairValue.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_SlidingSurfacePairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <StepGeom_PointOnSurface.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWSlidingSurfacePairValue
+//purpose :
+//=======================================================================
+RWStepKinematics_RWSlidingSurfacePairValue::RWStepKinematics_RWSlidingSurfacePairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSlidingSurfacePairValue::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_SlidingSurfacePairValue)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,5,theArch,"sliding_surface_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Own fields of SlidingSurfacePairValue
+
+ Handle(StepGeom_PointOnSurface) aActualPointOnSurface1;
+ theData->ReadEntity (theNum, 3, "actual_point_on_surface1", theArch, STANDARD_TYPE(StepGeom_PointOnSurface), aActualPointOnSurface1);
+
+ Handle(StepGeom_PointOnSurface) aActualPointOnSurface2;
+ theData->ReadEntity (theNum, 4, "actual_point_on_surface2", theArch, STANDARD_TYPE(StepGeom_PointOnSurface), aActualPointOnSurface2);
+
+ Standard_Real aActualRotation;
+ theData->ReadReal (theNum, 5, "actual_rotation", theArch, aActualRotation);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair,
+ aActualPointOnSurface1,
+ aActualPointOnSurface2,
+ aActualRotation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSlidingSurfacePairValue::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_SlidingSurfacePairValue)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Own fields of PairValue
+
+ theSW.Send (theEnt->AppliesToPair());
+
+ // Own fields of SlidingSurfacePairValue
+
+ theSW.Send (theEnt->ActualPointOnSurface1());
+
+ theSW.Send (theEnt->ActualPointOnSurface2());
+
+ theSW.Send (theEnt->ActualRotation());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSlidingSurfacePairValue::Share (const Handle(StepKinematics_SlidingSurfacePairValue)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair());
+
+ // Own fields of SlidingSurfacePairValue
+
+ iter.AddItem (theEnt->ActualPointOnSurface1());
+
+ iter.AddItem (theEnt->ActualPointOnSurface2());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWSlidingSurfacePairValue_HeaderFile_
+#define _RWStepKinematics_RWSlidingSurfacePairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_SlidingSurfacePairValue;
+
+//! Read & Write tool for SlidingSurfacePairValue
+class RWStepKinematics_RWSlidingSurfacePairValue
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWSlidingSurfacePairValue();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_SlidingSurfacePairValue)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_SlidingSurfacePairValue)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_SlidingSurfacePairValue)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWSlidingSurfacePairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWSphericalPair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_SphericalPair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWSphericalPair
+//purpose :
+//=======================================================================
+RWStepKinematics_RWSphericalPair::RWStepKinematics_RWSphericalPair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSphericalPair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_SphericalPair)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,12,theArch,"spherical_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSphericalPair::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_SphericalPair)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ theSW.SendBoolean (theEnt->TX());
+
+ theSW.SendBoolean (theEnt->TY());
+
+ theSW.SendBoolean (theEnt->TZ());
+
+ theSW.SendBoolean (theEnt->RX());
+
+ theSW.SendBoolean (theEnt->RY());
+
+ theSW.SendBoolean (theEnt->RZ());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSphericalPair::Share (const Handle(StepKinematics_SphericalPair)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWSphericalPair_HeaderFile_
+#define _RWStepKinematics_RWSphericalPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_SphericalPair;
+
+//! Read & Write tool for SphericalPair
+class RWStepKinematics_RWSphericalPair
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWSphericalPair();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_SphericalPair)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_SphericalPair)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_SphericalPair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWSphericalPair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWSphericalPairValue.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_SphericalPairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <StepKinematics_SpatialRotation.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWSphericalPairValue
+//purpose :
+//=======================================================================
+RWStepKinematics_RWSphericalPairValue::RWStepKinematics_RWSphericalPairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSphericalPairValue::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_SphericalPairValue)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,3,theArch,"spherical_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+
+ // Own fields of SphericalPairValue
+ StepKinematics_SpatialRotation aInputOrientation;
+ if (theData->SubListNumber(theNum, 3, Standard_True))
+ {
+ Handle(TColStd_HArray1OfReal) aItems;
+ Standard_Integer nsub = 0;
+ if (theData->ReadSubList(theNum, 3, "items", theArch, nsub)) {
+ Standard_Integer nb = theData->NbParams(nsub);
+ aItems = new TColStd_HArray1OfReal(1, nb);
+ Standard_Integer num2 = nsub;
+ for (Standard_Integer i0 = 1; i0 <= nb; i0++) {
+ Standard_Real anIt0;
+ theData->ReadReal(num2, i0, "real", theArch, anIt0);
+ aItems->SetValue(i0, anIt0);
+ }
+ }
+ aInputOrientation.SetValue(aItems);
+ }
+ else
+ theData->ReadEntity (theNum, 3, "input_orientation", theArch, aInputOrientation);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair,
+ aInputOrientation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSphericalPairValue::WriteStep(StepData_StepWriter& theSW,
+ const Handle(StepKinematics_SphericalPairValue)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send(theEnt->Name());
+
+ // Own fields of PairValue
+
+ theSW.Send(theEnt->AppliesToPair());
+
+ // Own fields of SphericalPairValue
+
+ if (!theEnt->InputOrientation().YprRotation().IsNull())
+ {
+ // Inherited field : YPR
+ theSW.OpenSub();
+ for (Standard_Integer i = 1; i <= theEnt->InputOrientation().YprRotation()->Length(); i++) {
+ theSW.Send(theEnt->InputOrientation().YprRotation()->Value(i));
+ }
+ theSW.CloseSub();
+ }
+ else
+ theSW.Send(theEnt->InputOrientation().Value());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSphericalPairValue::Share (const Handle(StepKinematics_SphericalPairValue)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair());
+
+ // Own fields of SphericalPairValue
+
+ if (!theEnt->InputOrientation().RotationAboutDirection().IsNull())
+ iter.AddItem(theEnt->InputOrientation().Value());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWSphericalPairValue_HeaderFile_
+#define _RWStepKinematics_RWSphericalPairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_SphericalPairValue;
+
+//! Read & Write tool for SphericalPairValue
+class RWStepKinematics_RWSphericalPairValue
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWSphericalPairValue();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_SphericalPairValue)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_SphericalPairValue)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_SphericalPairValue)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWSphericalPairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWSphericalPairWithPin.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_SphericalPairWithPin.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWSphericalPairWithPin
+//purpose :
+//=======================================================================
+RWStepKinematics_RWSphericalPairWithPin::RWStepKinematics_RWSphericalPairWithPin() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSphericalPairWithPin::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_SphericalPairWithPin)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,12,theArch,"spherical_pair_with_pin") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSphericalPairWithPin::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_SphericalPairWithPin)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ theSW.SendBoolean (theEnt->TX());
+
+ theSW.SendBoolean (theEnt->TY());
+
+ theSW.SendBoolean (theEnt->TZ());
+
+ theSW.SendBoolean (theEnt->RX());
+
+ theSW.SendBoolean (theEnt->RY());
+
+ theSW.SendBoolean (theEnt->RZ());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSphericalPairWithPin::Share (const Handle(StepKinematics_SphericalPairWithPin)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWSphericalPairWithPin_HeaderFile_
+#define _RWStepKinematics_RWSphericalPairWithPin_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_SphericalPairWithPin;
+
+//! Read & Write tool for SphericalPairWithPin
+class RWStepKinematics_RWSphericalPairWithPin
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWSphericalPairWithPin();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_SphericalPairWithPin)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_SphericalPairWithPin)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_SphericalPairWithPin)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWSphericalPairWithPin_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWSphericalPairWithPinAndRange.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_SphericalPairWithPinAndRange.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWSphericalPairWithPinAndRange
+//purpose :
+//=======================================================================
+RWStepKinematics_RWSphericalPairWithPinAndRange::RWStepKinematics_RWSphericalPairWithPinAndRange() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSphericalPairWithPinAndRange::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_SphericalPairWithPinAndRange)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,16,theArch,"spherical_pair_with_pin_and_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ);
+
+ // Own fields of SphericalPairWithPinAndRange
+
+ Standard_Real aLowerLimitYaw;
+ Standard_Boolean hasLowerLimitYaw = Standard_True;
+ if ( theData->IsParamDefined (theNum,13) ) {
+ theData->ReadReal (theNum, 13, "lower_limit_yaw", theArch, aLowerLimitYaw);
+ }
+ else {
+ hasLowerLimitYaw = Standard_False;
+ aLowerLimitYaw = 0;
+ }
+
+ Standard_Real aUpperLimitYaw;
+ Standard_Boolean hasUpperLimitYaw = Standard_True;
+ if ( theData->IsParamDefined (theNum,14) ) {
+ theData->ReadReal (theNum, 14, "upper_limit_yaw", theArch, aUpperLimitYaw);
+ }
+ else {
+ hasUpperLimitYaw = Standard_False;
+ aUpperLimitYaw = 0;
+ }
+
+ Standard_Real aLowerLimitRoll;
+ Standard_Boolean hasLowerLimitRoll = Standard_True;
+ if ( theData->IsParamDefined (theNum,15) ) {
+ theData->ReadReal (theNum, 15, "lower_limit_roll", theArch, aLowerLimitRoll);
+ }
+ else {
+ hasLowerLimitRoll = Standard_False;
+ aLowerLimitRoll = 0;
+ }
+
+ Standard_Real aUpperLimitRoll;
+ Standard_Boolean hasUpperLimitRoll = Standard_True;
+ if ( theData->IsParamDefined (theNum,16) ) {
+ theData->ReadReal (theNum, 16, "upper_limit_roll", theArch, aUpperLimitRoll);
+ }
+ else {
+ hasUpperLimitRoll = Standard_False;
+ aUpperLimitRoll = 0;
+ }
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ,
+ hasLowerLimitYaw,
+ aLowerLimitYaw,
+ hasUpperLimitYaw,
+ aUpperLimitYaw,
+ hasLowerLimitRoll,
+ aLowerLimitRoll,
+ hasUpperLimitRoll,
+ aUpperLimitRoll);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSphericalPairWithPinAndRange::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_SphericalPairWithPinAndRange)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ theSW.SendBoolean (theEnt->TX());
+
+ theSW.SendBoolean (theEnt->TY());
+
+ theSW.SendBoolean (theEnt->TZ());
+
+ theSW.SendBoolean (theEnt->RX());
+
+ theSW.SendBoolean (theEnt->RY());
+
+ theSW.SendBoolean (theEnt->RZ());
+
+ // Own fields of SphericalPairWithPinAndRange
+
+ if ( theEnt->HasLowerLimitYaw() ) {
+ theSW.Send (theEnt->LowerLimitYaw());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitYaw() ) {
+ theSW.Send (theEnt->UpperLimitYaw());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasLowerLimitRoll() ) {
+ theSW.Send (theEnt->LowerLimitRoll());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitRoll() ) {
+ theSW.Send (theEnt->UpperLimitRoll());
+ }
+ else theSW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSphericalPairWithPinAndRange::Share (const Handle(StepKinematics_SphericalPairWithPinAndRange)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+
+ // Own fields of SphericalPairWithPinAndRange
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWSphericalPairWithPinAndRange_HeaderFile_
+#define _RWStepKinematics_RWSphericalPairWithPinAndRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_SphericalPairWithPinAndRange;
+
+//! Read & Write tool for SphericalPairWithPinAndRange
+class RWStepKinematics_RWSphericalPairWithPinAndRange
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWSphericalPairWithPinAndRange();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_SphericalPairWithPinAndRange)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_SphericalPairWithPinAndRange)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_SphericalPairWithPinAndRange)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWSphericalPairWithPinAndRange_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWSphericalPairWithRange.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_SphericalPairWithRange.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWSphericalPairWithRange
+//purpose :
+//=======================================================================
+RWStepKinematics_RWSphericalPairWithRange::RWStepKinematics_RWSphericalPairWithRange() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSphericalPairWithRange::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_SphericalPairWithRange)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,18,theArch,"spherical_pair_with_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ);
+
+ // Own fields of SphericalPairWithRange
+
+ Standard_Real aLowerLimitYaw;
+ Standard_Boolean hasLowerLimitYaw = Standard_True;
+ if ( theData->IsParamDefined (theNum,13) ) {
+ theData->ReadReal (theNum, 13, "lower_limit_yaw", theArch, aLowerLimitYaw);
+ }
+ else {
+ hasLowerLimitYaw = Standard_False;
+ aLowerLimitYaw = 0;
+ }
+
+ Standard_Real aUpperLimitYaw;
+ Standard_Boolean hasUpperLimitYaw = Standard_True;
+ if ( theData->IsParamDefined (theNum,14) ) {
+ theData->ReadReal (theNum, 14, "upper_limit_yaw", theArch, aUpperLimitYaw);
+ }
+ else {
+ hasUpperLimitYaw = Standard_False;
+ aUpperLimitYaw = 0;
+ }
+
+ Standard_Real aLowerLimitPitch;
+ Standard_Boolean hasLowerLimitPitch = Standard_True;
+ if ( theData->IsParamDefined (theNum,15) ) {
+ theData->ReadReal (theNum, 15, "lower_limit_pitch", theArch, aLowerLimitPitch);
+ }
+ else {
+ hasLowerLimitPitch = Standard_False;
+ aLowerLimitPitch = 0;
+ }
+
+ Standard_Real aUpperLimitPitch;
+ Standard_Boolean hasUpperLimitPitch = Standard_True;
+ if ( theData->IsParamDefined (theNum,16) ) {
+ theData->ReadReal (theNum, 16, "upper_limit_pitch", theArch, aUpperLimitPitch);
+ }
+ else {
+ hasUpperLimitPitch = Standard_False;
+ aUpperLimitPitch = 0;
+ }
+
+ Standard_Real aLowerLimitRoll;
+ Standard_Boolean hasLowerLimitRoll = Standard_True;
+ if ( theData->IsParamDefined (theNum,17) ) {
+ theData->ReadReal (theNum, 17, "lower_limit_roll", theArch, aLowerLimitRoll);
+ }
+ else {
+ hasLowerLimitRoll = Standard_False;
+ aLowerLimitRoll = 0;
+ }
+
+ Standard_Real aUpperLimitRoll;
+ Standard_Boolean hasUpperLimitRoll = Standard_True;
+ if ( theData->IsParamDefined (theNum,18) ) {
+ theData->ReadReal (theNum, 18, "upper_limit_roll", theArch, aUpperLimitRoll);
+ }
+ else {
+ hasUpperLimitRoll = Standard_False;
+ aUpperLimitRoll = 0;
+ }
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ,
+ hasLowerLimitYaw,
+ aLowerLimitYaw,
+ hasUpperLimitYaw,
+ aUpperLimitYaw,
+ hasLowerLimitPitch,
+ aLowerLimitPitch,
+ hasUpperLimitPitch,
+ aUpperLimitPitch,
+ hasLowerLimitRoll,
+ aLowerLimitRoll,
+ hasUpperLimitRoll,
+ aUpperLimitRoll);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSphericalPairWithRange::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_SphericalPairWithRange)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ theSW.SendBoolean (theEnt->TX());
+
+ theSW.SendBoolean (theEnt->TY());
+
+ theSW.SendBoolean (theEnt->TZ());
+
+ theSW.SendBoolean (theEnt->RX());
+
+ theSW.SendBoolean (theEnt->RY());
+
+ theSW.SendBoolean (theEnt->RZ());
+
+ // Own fields of SphericalPairWithRange
+
+ if ( theEnt->HasLowerLimitYaw() ) {
+ theSW.Send (theEnt->LowerLimitYaw());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitYaw() ) {
+ theSW.Send (theEnt->UpperLimitYaw());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasLowerLimitPitch() ) {
+ theSW.Send (theEnt->LowerLimitPitch());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitPitch() ) {
+ theSW.Send (theEnt->UpperLimitPitch());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasLowerLimitRoll() ) {
+ theSW.Send (theEnt->LowerLimitRoll());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitRoll() ) {
+ theSW.Send (theEnt->UpperLimitRoll());
+ }
+ else theSW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSphericalPairWithRange::Share (const Handle(StepKinematics_SphericalPairWithRange)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+
+ // Own fields of SphericalPairWithRange
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWSphericalPairWithRange_HeaderFile_
+#define _RWStepKinematics_RWSphericalPairWithRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_SphericalPairWithRange;
+
+//! Read & Write tool for SphericalPairWithRange
+class RWStepKinematics_RWSphericalPairWithRange
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWSphericalPairWithRange();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_SphericalPairWithRange)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_SphericalPairWithRange)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_SphericalPairWithRange)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWSphericalPairWithRange_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWSurfacePairWithRange.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_SurfacePairWithRange.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Surface.hxx>
+#include <Standard_Boolean.hxx>
+#include <StepGeom_RectangularTrimmedSurface.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWSurfacePairWithRange
+//purpose :
+//=======================================================================
+RWStepKinematics_RWSurfacePairWithRange::RWStepKinematics_RWSurfacePairWithRange() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSurfacePairWithRange::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_SurfacePairWithRange)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,13,theArch,"surface_pair_with_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of SurfacePair
+
+ Handle(StepGeom_Surface) aSurfacePair_Surface1;
+ theData->ReadEntity (theNum, 7, "surface_pair.surface1", theArch, STANDARD_TYPE(StepGeom_Surface), aSurfacePair_Surface1);
+
+ Handle(StepGeom_Surface) aSurfacePair_Surface2;
+ theData->ReadEntity (theNum, 8, "surface_pair.surface2", theArch, STANDARD_TYPE(StepGeom_Surface), aSurfacePair_Surface2);
+
+ Standard_Boolean aSurfacePair_Orientation;
+ theData->ReadBoolean (theNum, 9, "surface_pair.orientation", theArch, aSurfacePair_Orientation);
+
+ // Own fields of SurfacePairWithRange
+
+ Handle(StepGeom_RectangularTrimmedSurface) aRangeOnSurface1;
+ theData->ReadEntity (theNum, 10, "range_on_surface1", theArch, STANDARD_TYPE(StepGeom_RectangularTrimmedSurface), aRangeOnSurface1);
+
+ Handle(StepGeom_RectangularTrimmedSurface) aRangeOnSurface2;
+ theData->ReadEntity (theNum, 11, "range_on_surface2", theArch, STANDARD_TYPE(StepGeom_RectangularTrimmedSurface), aRangeOnSurface2);
+
+ Standard_Real aLowerLimitActualRotation;
+ Standard_Boolean hasLowerLimitActualRotation = Standard_True;
+ if ( theData->IsParamDefined (theNum,12) ) {
+ theData->ReadReal (theNum, 12, "lower_limit_actual_rotation", theArch, aLowerLimitActualRotation);
+ }
+ else {
+ hasLowerLimitActualRotation = Standard_False;
+ aLowerLimitActualRotation = 0;
+ }
+
+ Standard_Real aUpperLimitActualRotation;
+ Standard_Boolean hasUpperLimitActualRotation = Standard_True;
+ if ( theData->IsParamDefined (theNum,13) ) {
+ theData->ReadReal (theNum, 13, "upper_limit_actual_rotation", theArch, aUpperLimitActualRotation);
+ }
+ else {
+ hasUpperLimitActualRotation = Standard_False;
+ aUpperLimitActualRotation = 0;
+ }
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aSurfacePair_Surface1,
+ aSurfacePair_Surface2,
+ aSurfacePair_Orientation,
+ aRangeOnSurface1,
+ aRangeOnSurface2,
+ hasLowerLimitActualRotation,
+ aLowerLimitActualRotation,
+ hasUpperLimitActualRotation,
+ aUpperLimitActualRotation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSurfacePairWithRange::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_SurfacePairWithRange)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of SurfacePair
+
+ theSW.Send (theEnt->Surface1());
+
+ theSW.Send (theEnt->Surface2());
+
+ theSW.SendBoolean (theEnt->Orientation());
+
+ // Own fields of SurfacePairWithRange
+
+ theSW.Send (theEnt->RangeOnSurface1());
+
+ theSW.Send (theEnt->RangeOnSurface2());
+
+ if ( theEnt->HasLowerLimitActualRotation() ) {
+ theSW.Send (theEnt->LowerLimitActualRotation());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitActualRotation() ) {
+ theSW.Send (theEnt->UpperLimitActualRotation());
+ }
+ else theSW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWSurfacePairWithRange::Share (const Handle(StepKinematics_SurfacePairWithRange)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of SurfacePair
+
+ iter.AddItem (theEnt->StepKinematics_SurfacePair::Surface1());
+
+ iter.AddItem (theEnt->StepKinematics_SurfacePair::Surface2());
+
+ // Own fields of SurfacePairWithRange
+
+ iter.AddItem (theEnt->RangeOnSurface1());
+
+ iter.AddItem (theEnt->RangeOnSurface2());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWSurfacePairWithRange_HeaderFile_
+#define _RWStepKinematics_RWSurfacePairWithRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_SurfacePairWithRange;
+
+//! Read & Write tool for SurfacePairWithRange
+class RWStepKinematics_RWSurfacePairWithRange
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWSurfacePairWithRange();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_SurfacePairWithRange)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_SurfacePairWithRange)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_SurfacePairWithRange)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWSurfacePairWithRange_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWUnconstrainedPair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_UnconstrainedPair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWUnconstrainedPair
+//purpose :
+//=======================================================================
+RWStepKinematics_RWUnconstrainedPair::RWStepKinematics_RWUnconstrainedPair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWUnconstrainedPair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_UnconstrainedPair)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,12,theArch,"unconstrained_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWUnconstrainedPair::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_UnconstrainedPair)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ theSW.SendBoolean (theEnt->TX());
+
+ theSW.SendBoolean (theEnt->TY());
+
+ theSW.SendBoolean (theEnt->TZ());
+
+ theSW.SendBoolean (theEnt->RX());
+
+ theSW.SendBoolean (theEnt->RY());
+
+ theSW.SendBoolean (theEnt->RZ());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWUnconstrainedPair::Share (const Handle(StepKinematics_UnconstrainedPair)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWUnconstrainedPair_HeaderFile_
+#define _RWStepKinematics_RWUnconstrainedPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_UnconstrainedPair;
+
+//! Read & Write tool for UnconstrainedPair
+class RWStepKinematics_RWUnconstrainedPair
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWUnconstrainedPair();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_UnconstrainedPair)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_UnconstrainedPair)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_UnconstrainedPair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWUnconstrainedPair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWUnconstrainedPairValue.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_UnconstrainedPairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <StepGeom_Axis2Placement3d.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWUnconstrainedPairValue
+//purpose :
+//=======================================================================
+RWStepKinematics_RWUnconstrainedPairValue::RWStepKinematics_RWUnconstrainedPairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWUnconstrainedPairValue::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_UnconstrainedPairValue)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,3,theArch,"unconstrained_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Own fields of UnconstrainedPairValue
+
+ Handle(StepGeom_Axis2Placement3d) aActualPlacement;
+ theData->ReadEntity (theNum, 3, "actual_placement", theArch, STANDARD_TYPE(StepGeom_Axis2Placement3d), aActualPlacement);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair,
+ aActualPlacement);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWUnconstrainedPairValue::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_UnconstrainedPairValue)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Own fields of PairValue
+
+ theSW.Send (theEnt->AppliesToPair());
+
+ // Own fields of UnconstrainedPairValue
+
+ theSW.Send (theEnt->ActualPlacement());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWUnconstrainedPairValue::Share (const Handle(StepKinematics_UnconstrainedPairValue)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair());
+
+ // Own fields of UnconstrainedPairValue
+
+ iter.AddItem (theEnt->ActualPlacement());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWUnconstrainedPairValue_HeaderFile_
+#define _RWStepKinematics_RWUnconstrainedPairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_UnconstrainedPairValue;
+
+//! Read & Write tool for UnconstrainedPairValue
+class RWStepKinematics_RWUnconstrainedPairValue
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWUnconstrainedPairValue();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_UnconstrainedPairValue)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_UnconstrainedPairValue)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_UnconstrainedPairValue)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWUnconstrainedPairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWUniversalPair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_UniversalPair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWUniversalPair
+//purpose :
+//=======================================================================
+RWStepKinematics_RWUniversalPair::RWStepKinematics_RWUniversalPair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWUniversalPair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_UniversalPair)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,13,theArch,"universal_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ);
+
+ // Own fields of UniversalPair
+
+ Standard_Real aInputSkewAngle;
+ Standard_Boolean hasInputSkewAngle = Standard_True;
+ if ( theData->IsParamDefined (theNum,13) ) {
+ theData->ReadReal (theNum, 13, "input_skew_angle", theArch, aInputSkewAngle);
+ }
+ else {
+ hasInputSkewAngle = Standard_False;
+ aInputSkewAngle = 0;
+ }
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ,
+ hasInputSkewAngle,
+ aInputSkewAngle);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWUniversalPair::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_UniversalPair)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ theSW.SendBoolean (theEnt->TX());
+
+ theSW.SendBoolean (theEnt->TY());
+
+ theSW.SendBoolean (theEnt->TZ());
+
+ theSW.SendBoolean (theEnt->RX());
+
+ theSW.SendBoolean (theEnt->RY());
+
+ theSW.SendBoolean (theEnt->RZ());
+
+ // Own fields of UniversalPair
+
+ if ( theEnt->HasInputSkewAngle() ) {
+ theSW.Send (theEnt->InputSkewAngle());
+ }
+ else theSW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWUniversalPair::Share (const Handle(StepKinematics_UniversalPair)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+
+ // Own fields of UniversalPair
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWUniversalPair_HeaderFile_
+#define _RWStepKinematics_RWUniversalPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_UniversalPair;
+
+//! Read & Write tool for UniversalPair
+class RWStepKinematics_RWUniversalPair
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWUniversalPair();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_UniversalPair)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_UniversalPair)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_UniversalPair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWUniversalPair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWUniversalPairValue.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_UniversalPairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWUniversalPairValue
+//purpose :
+//=======================================================================
+RWStepKinematics_RWUniversalPairValue::RWStepKinematics_RWUniversalPairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWUniversalPairValue::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_UniversalPairValue)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,4,theArch,"universal_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Own fields of UniversalPairValue
+
+ Standard_Real aFirstRotationAngle;
+ theData->ReadReal (theNum, 3, "first_rotation_angle", theArch, aFirstRotationAngle);
+
+ Standard_Real aSecondRotationAngle;
+ theData->ReadReal (theNum, 4, "second_rotation_angle", theArch, aSecondRotationAngle);
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair,
+ aFirstRotationAngle,
+ aSecondRotationAngle);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWUniversalPairValue::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_UniversalPairValue)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Own fields of PairValue
+
+ theSW.Send (theEnt->AppliesToPair());
+
+ // Own fields of UniversalPairValue
+
+ theSW.Send (theEnt->FirstRotationAngle());
+
+ theSW.Send (theEnt->SecondRotationAngle());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWUniversalPairValue::Share (const Handle(StepKinematics_UniversalPairValue)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair());
+
+ // Own fields of UniversalPairValue
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWUniversalPairValue_HeaderFile_
+#define _RWStepKinematics_RWUniversalPairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_UniversalPairValue;
+
+//! Read & Write tool for UniversalPairValue
+class RWStepKinematics_RWUniversalPairValue
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWUniversalPairValue();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_UniversalPairValue)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_UniversalPairValue)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_UniversalPairValue)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWUniversalPairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepKinematics_RWUniversalPairWithRange.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_UniversalPairWithRange.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWUniversalPairWithRange
+//purpose :
+//=======================================================================
+RWStepKinematics_RWUniversalPairWithRange::RWStepKinematics_RWUniversalPairWithRange() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWUniversalPairWithRange::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theArch,
+ const Handle(StepKinematics_UniversalPairWithRange)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,17,theArch,"universal_pair_with_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( theData->IsParamDefined (theNum,3) ) {
+ theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ);
+
+ // Inherited fields of UniversalPair
+
+ Standard_Real aUniversalPair_InputSkewAngle;
+ Standard_Boolean hasUniversalPair_InputSkewAngle = Standard_True;
+ if ( theData->IsParamDefined (theNum,13) ) {
+ theData->ReadReal (theNum, 13, "universal_pair.input_skew_angle", theArch, aUniversalPair_InputSkewAngle);
+ }
+ else {
+ hasUniversalPair_InputSkewAngle = Standard_False;
+ aUniversalPair_InputSkewAngle = 0;
+ }
+
+ // Own fields of UniversalPairWithRange
+
+ Standard_Real aLowerLimitFirstRotation;
+ Standard_Boolean hasLowerLimitFirstRotation = Standard_True;
+ if ( theData->IsParamDefined (theNum,14) ) {
+ theData->ReadReal (theNum, 14, "lower_limit_first_rotation", theArch, aLowerLimitFirstRotation);
+ }
+ else {
+ hasLowerLimitFirstRotation = Standard_False;
+ aLowerLimitFirstRotation = 0;
+ }
+
+ Standard_Real aUpperLimitFirstRotation;
+ Standard_Boolean hasUpperLimitFirstRotation = Standard_True;
+ if ( theData->IsParamDefined (theNum,15) ) {
+ theData->ReadReal (theNum, 15, "upper_limit_first_rotation", theArch, aUpperLimitFirstRotation);
+ }
+ else {
+ hasUpperLimitFirstRotation = Standard_False;
+ aUpperLimitFirstRotation = 0;
+ }
+
+ Standard_Real aLowerLimitSecondRotation;
+ Standard_Boolean hasLowerLimitSecondRotation = Standard_True;
+ if ( theData->IsParamDefined (theNum,16) ) {
+ theData->ReadReal (theNum, 16, "lower_limit_second_rotation", theArch, aLowerLimitSecondRotation);
+ }
+ else {
+ hasLowerLimitSecondRotation = Standard_False;
+ aLowerLimitSecondRotation = 0;
+ }
+
+ Standard_Real aUpperLimitSecondRotation;
+ Standard_Boolean hasUpperLimitSecondRotation = Standard_True;
+ if ( theData->IsParamDefined (theNum,17) ) {
+ theData->ReadReal (theNum, 17, "upper_limit_second_rotation", theArch, aUpperLimitSecondRotation);
+ }
+ else {
+ hasUpperLimitSecondRotation = Standard_False;
+ aUpperLimitSecondRotation = 0;
+ }
+
+ // Initialize entity
+ theEnt->Init(aRepresentationItem_Name,
+ aItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ aItemDefinedTransformation_Description,
+ aItemDefinedTransformation_TransformItem1,
+ aItemDefinedTransformation_TransformItem2,
+ aKinematicPair_Joint,
+ aLowOrderKinematicPair_TX,
+ aLowOrderKinematicPair_TY,
+ aLowOrderKinematicPair_TZ,
+ aLowOrderKinematicPair_RX,
+ aLowOrderKinematicPair_RY,
+ aLowOrderKinematicPair_RZ,
+ hasUniversalPair_InputSkewAngle,
+ aUniversalPair_InputSkewAngle,
+ hasLowerLimitFirstRotation,
+ aLowerLimitFirstRotation,
+ hasUpperLimitFirstRotation,
+ aUpperLimitFirstRotation,
+ hasLowerLimitSecondRotation,
+ aLowerLimitSecondRotation,
+ hasUpperLimitSecondRotation,
+ aUpperLimitSecondRotation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWUniversalPairWithRange::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepKinematics_UniversalPairWithRange)& theEnt) const
+{
+
+ // Own fields of RepresentationItem
+
+ theSW.Send (theEnt->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+ if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+ theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+ }
+ else theSW.SendUndef();
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ theSW.Send (theEnt->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ theSW.SendBoolean (theEnt->TX());
+
+ theSW.SendBoolean (theEnt->TY());
+
+ theSW.SendBoolean (theEnt->TZ());
+
+ theSW.SendBoolean (theEnt->RX());
+
+ theSW.SendBoolean (theEnt->RY());
+
+ theSW.SendBoolean (theEnt->RZ());
+
+ // Own fields of UniversalPair
+
+ if ( theEnt->HasInputSkewAngle() ) {
+ theSW.Send (theEnt->InputSkewAngle());
+ }
+ else theSW.SendUndef();
+
+ // Own fields of UniversalPairWithRange
+
+ if ( theEnt->HasLowerLimitFirstRotation() ) {
+ theSW.Send (theEnt->LowerLimitFirstRotation());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitFirstRotation() ) {
+ theSW.Send (theEnt->UpperLimitFirstRotation());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasLowerLimitSecondRotation() ) {
+ theSW.Send (theEnt->LowerLimitSecondRotation());
+ }
+ else theSW.SendUndef();
+
+ if ( theEnt->HasUpperLimitSecondRotation() ) {
+ theSW.Send (theEnt->UpperLimitSecondRotation());
+ }
+ else theSW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+void RWStepKinematics_RWUniversalPairWithRange::Share (const Handle(StepKinematics_UniversalPairWithRange)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+
+ // Inherited fields of UniversalPair
+
+ // Own fields of UniversalPairWithRange
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepKinematics_RWUniversalPairWithRange_HeaderFile_
+#define _RWStepKinematics_RWUniversalPairWithRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_UniversalPairWithRange;
+
+//! Read & Write tool for UniversalPairWithRange
+class RWStepKinematics_RWUniversalPairWithRange
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWUniversalPairWithRange();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_UniversalPairWithRange)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_UniversalPairWithRange)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_UniversalPairWithRange)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWUniversalPairWithRange_HeaderFile_
RWStepRepr_RWRepresentation.hxx
RWStepRepr_RWRepresentationContext.cxx
RWStepRepr_RWRepresentationContext.hxx
+RWStepRepr_RWRepresentationContextReference.cxx
+RWStepRepr_RWRepresentationContextReference.hxx
RWStepRepr_RWRepresentationItem.cxx
RWStepRepr_RWRepresentationItem.hxx
RWStepRepr_RWRepresentationMap.cxx
RWStepRepr_RWRepresentationMap.hxx
+RWStepRepr_RWRepresentationReference.cxx
+RWStepRepr_RWRepresentationReference.hxx
RWStepRepr_RWRepresentationRelationship.cxx
RWStepRepr_RWRepresentationRelationship.hxx
RWStepRepr_RWRepresentationRelationshipWithTransformation.cxx
--- /dev/null
+// Created on : Sat May 02 12:41:14 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepRepr_RWRepresentationContextReference.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepRepr_RepresentationContextReference.hxx>
+#include <TCollection_HAsciiString.hxx>
+
+//=======================================================================
+//function : RWStepRepr_RWRepresentationContextReference
+//purpose :
+//=======================================================================
+
+RWStepRepr_RWRepresentationContextReference::RWStepRepr_RWRepresentationContextReference() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWRepresentationContextReference::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theAch,
+ const Handle(StepRepr_RepresentationContextReference)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,1,theAch,"representation_context_reference") ) return;
+
+ // Own fields of RepresentationContextReference
+
+ Handle(TCollection_HAsciiString) aContextIdentifier;
+ theData->ReadString (theNum, 1, "context_identifier", theAch, aContextIdentifier);
+
+ // Initialize entity
+ theEnt->Init(aContextIdentifier);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWRepresentationContextReference::WriteStep (StepData_StepWriter& theSW,
+ const Handle(StepRepr_RepresentationContextReference)& theEnt) const
+{
+
+ // Own fields of RepresentationContextReference
+
+ theSW.Send (theEnt->ContextIdentifier());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWRepresentationContextReference::Share (const Handle(StepRepr_RepresentationContextReference)& /*theEnt*/,
+ Interface_EntityIterator& /*iter*/) const
+{
+
+ // Own fields of RepresentationContextReference
+}
--- /dev/null
+// Created on : Sat May 02 12:41:14 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepRepr_RWRepresentationContextReference_HeaderFile_
+#define _RWStepRepr_RWRepresentationContextReference_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepRepr_RepresentationContextReference;
+
+//! Read & Write tool for RepresentationContextReference
+class RWStepRepr_RWRepresentationContextReference
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepRepr_RWRepresentationContextReference();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theAch, const Handle(StepRepr_RepresentationContextReference)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepRepr_RepresentationContextReference)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepRepr_RepresentationContextReference)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepRepr_RWRepresentationContextReference_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:14 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <RWStepRepr_RWRepresentationReference.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepRepr_RepresentationReference.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationContextReference.hxx>
+
+//=======================================================================
+//function : RWStepRepr_RWRepresentationReference
+//purpose :
+//=======================================================================
+
+RWStepRepr_RWRepresentationReference::RWStepRepr_RWRepresentationReference() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWRepresentationReference::ReadStep (const Handle(StepData_StepReaderData)& theData,
+ const Standard_Integer theNum,
+ Handle(Interface_Check)& theAch,
+ const Handle(StepRepr_RepresentationReference)& theEnt) const
+{
+ // Check number of parameters
+ if ( ! theData->CheckNbParams(theNum,2,theAch,"representation_reference") ) return;
+
+ // Own fields of RepresentationReference
+
+ Handle(TCollection_HAsciiString) aId;
+ theData->ReadString (theNum, 1, "id", theAch, aId);
+
+ Handle(StepRepr_RepresentationContextReference) aContextOfItems;
+ theData->ReadEntity (theNum, 2, "context_of_items", theAch, STANDARD_TYPE(StepRepr_RepresentationContextReference), aContextOfItems);
+
+ // Initialize entity
+ theEnt->Init(aId,
+ aContextOfItems);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWRepresentationReference::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepRepr_RepresentationReference)& theEnt) const
+{
+
+ // Own fields of RepresentationReference
+
+ SW.Send (theEnt->Id());
+
+ SW.Send (theEnt->ContextOfItems());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWRepresentationReference::Share (const Handle(StepRepr_RepresentationReference)& theEnt,
+ Interface_EntityIterator& iter) const
+{
+
+ // Own fields of RepresentationReference
+
+ iter.AddItem (theEnt->ContextOfItems());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:14 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _RWStepRepr_RWRepresentationReference_HeaderFile_
+#define _RWStepRepr_RWRepresentationReference_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepRepr_RepresentationReference;
+
+//! Read & Write tool for RepresentationReference
+class RWStepRepr_RWRepresentationReference
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepRepr_RWRepresentationReference();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theAch, const Handle(StepRepr_RepresentationReference)& theEnt) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepRepr_RepresentationReference)& theEnt) const;
+
+ Standard_EXPORT void Share(const Handle(StepRepr_RepresentationReference)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepRepr_RWRepresentationReference_HeaderFile_
// necessary only in Writer, to set good actor: WS->SelectNorm ( "STEP" );
myReader.SetWS(WS, scratch);
myFiles.Clear();
+ myMap.Clear();
}
//=======================================================================
// and insert them to the document
Handle(XCAFDoc_ShapeTool) STool = XCAFDoc_DocumentTool::ShapeTool(doc->Main());
if (STool.IsNull()) return Standard_False;
- XCAFDoc_DataMapOfShapeLabel map;
if (asOne)
- Lseq.Append(AddShape(reader.OneShape(), STool, NewShapesMap, ShapePDMap, PDFileMap, map));
+ Lseq.Append(AddShape(reader.OneShape(), STool, NewShapesMap, ShapePDMap, PDFileMap));
else {
for (i = 1; i <= num; i++) {
- Lseq.Append(AddShape(reader.Shape(i), STool, NewShapesMap, ShapePDMap, PDFileMap, map));
+ Lseq.Append(AddShape(reader.Shape(i), STool, NewShapesMap, ShapePDMap, PDFileMap));
}
}
// read colors
if (GetColorMode())
- ReadColors(reader.WS(), doc, map);
+ ReadColors(reader.WS(), doc);
// read names
if (GetNameMode())
- ReadNames(reader.WS(), doc, PDFileMap, map);
+ ReadNames(reader.WS(), doc, PDFileMap);
// read validation props
if (GetPropsMode())
- ReadValProps(reader.WS(), doc, PDFileMap, map);
+ ReadValProps(reader.WS(), doc, PDFileMap);
// read layers
if (GetLayerMode())
// read SHUO entities from STEP model
if (GetSHUOMode())
- ReadSHUOs(reader.WS(), doc, PDFileMap, map);
+ ReadSHUOs(reader.WS(), doc, PDFileMap);
// read GDT entities from STEP model
if (GetGDTMode())
// Expand resulting CAF structure for sub-shapes (optionally with their
// names) if requested
- ExpandSubShapes(STool, map, ShapePDMap);
+ ExpandSubShapes(STool, ShapePDMap);
// Update assembly compounds
STool->UpdateAssemblies();
const Handle(XCAFDoc_ShapeTool) &STool,
const TopTools_MapOfShape &NewShapesMap,
const STEPCAFControl_DataMapOfShapePD &ShapePDMap,
- const STEPCAFControl_DataMapOfPDExternFile &PDFileMap,
- XCAFDoc_DataMapOfShapeLabel &ShapeLabelMap) const
+ const STEPCAFControl_DataMapOfPDExternFile &PDFileMap)
{
// if shape has already been mapped, just return corresponding label
- if (ShapeLabelMap.IsBound(S)) {
- return ShapeLabelMap.Find(S);
+ if (myMap.IsBound(S)) {
+ return myMap.Find(S);
}
// if shape is located, create instance
TopoDS_Shape S0 = S;
TopLoc_Location loc;
S0.Location(loc);
- AddShape(S0, STool, NewShapesMap, ShapePDMap, PDFileMap, ShapeLabelMap);
+ AddShape(S0, STool, NewShapesMap, ShapePDMap, PDFileMap);
TDF_Label L = STool->AddShape(S, Standard_False); // should create reference
- ShapeLabelMap.Bind(S, L);
+ myMap.Bind(S, L);
return L;
}
// if shape is not compound, simple add it
if (S.ShapeType() != TopAbs_COMPOUND) {
TDF_Label L = STool->AddShape(S, Standard_False);
- ShapeLabelMap.Bind(S, L);
+ myMap.Bind(S, L);
return L;
}
if (!EF->GetLabel().IsNull()) {
// but if components >0, ignore extern ref!
if (nbComponents <= 0) {
- ShapeLabelMap.Bind(S, EF->GetLabel());
+ myMap.Bind(S, EF->GetLabel());
STool->SetExternRefs(EF->GetLabel(), SHAS);
return EF->GetLabel();
}
if (!isAssembly) {
TDF_Label L = STool->AddShape(S, Standard_False);
if (SHAS.Length() > 0) STool->SetExternRefs(L, SHAS);
- ShapeLabelMap.Bind(S, L);
+ myMap.Bind(S, L);
return L;
}
TopoDS_Shape Sub0 = it.Value();
TopLoc_Location loc;
Sub0.Location(loc);
- TDF_Label subL = AddShape(Sub0, STool, NewShapesMap, ShapePDMap, PDFileMap, ShapeLabelMap);
+ TDF_Label subL = AddShape(Sub0, STool, NewShapesMap, ShapePDMap, PDFileMap);
if (!subL.IsNull()) {
TDF_Label instL = STool->AddComponent(L, subL, it.Value().Location());
- if (!ShapeLabelMap.IsBound(it.Value())) {
- ShapeLabelMap.Bind(it.Value(), instL);
+ if (!myMap.IsBound(it.Value())) {
+ myMap.Bind(it.Value(), instL);
}
}
}
if (SHAS.Length() > 0) STool->SetExternRefs(L, SHAS);
- ShapeLabelMap.Bind(S, L);
+ myMap.Bind(S, L);
//STool->SetShape ( L, S ); // it is necessary for assemblies OCC1747 // commemted by skl for OCC2941
return L;
//=======================================================================
Standard_Boolean STEPCAFControl_Reader::ReadColors(const Handle(XSControl_WorkSession) &WS,
- Handle(TDocStd_Document)& Doc,
- const XCAFDoc_DataMapOfShapeLabel &ShapeLabelMap) const
+ Handle(TDocStd_Document)& Doc) const
{
STEPConstruct_Styles Styles(WS);
if (!Styles.LoadStyles()) {
TopoDS_Shape aSh;
// PTV 10.02.2003 to find component of assembly CORRECTLY
STEPConstruct_Tool Tool(WS);
- TDF_Label aShLab = FindInstance(NAUO, CTool->ShapeTool(), Tool, ShapeLabelMap);
+ TDF_Label aShLab = FindInstance(NAUO, CTool->ShapeTool(), Tool, myMap);
aSh = CTool->ShapeTool()->GetShape(aShLab);
if (!aSh.IsNull()) {
S = aSh;
Standard_Boolean STEPCAFControl_Reader::ReadNames(const Handle(XSControl_WorkSession) &WS,
Handle(TDocStd_Document)& Doc,
- const STEPCAFControl_DataMapOfPDExternFile &PDFileMap,
- const XCAFDoc_DataMapOfShapeLabel &ShapeLabelMap) const
+ const STEPCAFControl_DataMapOfPDExternFile &PDFileMap) const
{
// get starting data
const Handle(Interface_InterfaceModel) &Model = WS->Model();
else name = new TCollection_HAsciiString;
}
// find proper label
- L = FindInstance(NAUO, STool, Tool, ShapeLabelMap);
+ L = FindInstance(NAUO, STool, Tool, myMap);
if (L.IsNull()) continue;
TCollection_ExtendedString str = convertName (name->String());
name = Prod->Id();
else
name = new TCollection_HAsciiString;
- L = GetLabelFromPD(PD, STool, TP, PDFileMap, ShapeLabelMap);
+ L = GetLabelFromPD(PD, STool, TP, PDFileMap, myMap);
if (L.IsNull()) continue;
TCollection_ExtendedString str = convertName (name->String());
TDataStd_Name::Set(L, str);
Standard_Boolean STEPCAFControl_Reader::ReadValProps(const Handle(XSControl_WorkSession) &WS,
Handle(TDocStd_Document)& Doc,
- const STEPCAFControl_DataMapOfPDExternFile &PDFileMap,
- const XCAFDoc_DataMapOfShapeLabel &ShapeLabelMap) const
+ const STEPCAFControl_DataMapOfPDExternFile &PDFileMap) const
{
// get starting data
const Handle(XSControl_TransferReader) &TR = WS->TransferReader();
NAUO = Handle(StepRepr_NextAssemblyUsageOccurrence)::DownCast(subs1.Value());
}
if (!NAUO.IsNull()) {
- L = FindInstance(NAUO, STool, WS, ShapeLabelMap);
+ L = FindInstance(NAUO, STool, WS, myMap);
if (L.IsNull()) continue;
}
else {
ProdDef = Handle(StepBasic_ProductDefinition)::DownCast(subsPDS.Value());
}
if (ProdDef.IsNull()) continue;
- L = GetLabelFromPD(ProdDef, STool, Props, PDFileMap, ShapeLabelMap);
+ L = GetLabelFromPD(ProdDef, STool, Props, PDFileMap, myMap);
}
}
TopoDS_Shape S;
S = TransferBRep::ShapeResult(TP, binder);
if (S.IsNull()) continue;
- if (ShapeLabelMap.IsBound(S))
- L = ShapeLabelMap.Find(S);
+ if (myMap.IsBound(S))
+ L = myMap.Find(S);
if (L.IsNull())
STool->Search(S, L, Standard_True, Standard_True, Standard_True);
}
Standard_Boolean STEPCAFControl_Reader::ReadSHUOs(const Handle(XSControl_WorkSession) &WS,
Handle(TDocStd_Document)& Doc,
- const STEPCAFControl_DataMapOfPDExternFile &PDFileMap,
- const XCAFDoc_DataMapOfShapeLabel &ShapeLabelMap) const
+ const STEPCAFControl_DataMapOfPDExternFile &PDFileMap) const
{
// the big part code duplication from ReadColors.
// It is possible to share this code functionality, just to decide how ???
continue;
// set the SHUO structure to the document
- TDF_Label aLabelForStyle = setSHUOintoDoc(WS, SHUO, STool, PDFileMap, ShapeLabelMap);
+ TDF_Label aLabelForStyle = setSHUOintoDoc(WS, SHUO, STool, PDFileMap, myMap);
if (aLabelForStyle.IsNull()) {
#ifdef OCCT_DEBUG
std::cout << "Warning: " << __FILE__ << ": coudnot create SHUO structure in the document" << std::endl;
//=======================================================================
void STEPCAFControl_Reader::ExpandSubShapes(const Handle(XCAFDoc_ShapeTool)& ShapeTool,
- const XCAFDoc_DataMapOfShapeLabel& ShapeLabelMap,
const STEPCAFControl_DataMapOfShapePD& ShapePDMap) const
{
const Handle(Transfer_TransientProcess)& TP = Reader().WS()->TransferReader()->TransientProcess();
if (aReprItems.Length() == 0)
continue;
- if (!ShapeLabelMap.IsBound(aRootShape))
+ if (!myMap.IsBound(aRootShape))
continue;
- TDF_Label aRootLab = ShapeLabelMap.Find(aRootShape);
+ TDF_Label aRootLab = myMap.Find(aRootShape);
// Do not add subshapes to assembly,
// they will be processed with corresponding Shape_Product_Definition of necessary part.
if (ShapeTool->IsAssembly(aRootLab))
//! Get View mode
Standard_EXPORT Standard_Boolean GetViewMode() const;
-
-
+ const XCAFDoc_DataMapOfShapeLabel& GetShapeLabelMap() const { return myMap; }
protected:
//! Depending on a case, this shape can be added as one, or
//! as assembly, or (in case if it is associated with external
//! reference) taken as that referred shape
- Standard_EXPORT TDF_Label AddShape (const TopoDS_Shape& S, const Handle(XCAFDoc_ShapeTool)& STool, const TopTools_MapOfShape& NewShapesMap, const STEPCAFControl_DataMapOfShapePD& ShapePDMap, const STEPCAFControl_DataMapOfPDExternFile& PDFileMap, XCAFDoc_DataMapOfShapeLabel& ShapeLabelMap) const;
+ Standard_EXPORT TDF_Label AddShape (const TopoDS_Shape& S, const Handle(XCAFDoc_ShapeTool)& STool, const TopTools_MapOfShape& NewShapesMap, const STEPCAFControl_DataMapOfShapePD& ShapePDMap, const STEPCAFControl_DataMapOfPDExternFile& PDFileMap);
//! Reads (or if returns already read) extern file with
//! given name
//! corresponding color assignments in the DECAF document
Standard_EXPORT Standard_Boolean ReadColors
(const Handle(XSControl_WorkSession)& WS,
- Handle(TDocStd_Document)& doc,
- const XCAFDoc_DataMapOfShapeLabel& ShapeLabelMap) const;
+ Handle(TDocStd_Document)& doc) const;
//! Reads names of parts defined in the STEP model and
//! assigns them to corresponding labels in the DECAF document
- Standard_EXPORT Standard_Boolean ReadNames (const Handle(XSControl_WorkSession)& WS, Handle(TDocStd_Document)& doc, const STEPCAFControl_DataMapOfPDExternFile& PDFileMap, const XCAFDoc_DataMapOfShapeLabel& ShapeLabelMap) const;
+ Standard_EXPORT Standard_Boolean ReadNames (const Handle(XSControl_WorkSession)& WS, Handle(TDocStd_Document)& doc, const STEPCAFControl_DataMapOfPDExternFile& PDFileMap) const;
//! Reads validation properties assigned to shapes in the STEP
//! model and assigns them to corresponding labels in the DECAF
//! document
- Standard_EXPORT Standard_Boolean ReadValProps (const Handle(XSControl_WorkSession)& WS, Handle(TDocStd_Document)& doc, const STEPCAFControl_DataMapOfPDExternFile& PDFileMap, const XCAFDoc_DataMapOfShapeLabel& ShapeLabelMap) const;
+ Standard_EXPORT Standard_Boolean ReadValProps (const Handle(XSControl_WorkSession)& WS, Handle(TDocStd_Document)& doc, const STEPCAFControl_DataMapOfPDExternFile& PDFileMap) const;
//! Reads layers of parts defined in the STEP model and
//! set reference between shape and layers in the DECAF document
//! Reads SHUO for instances defined in the STEP model and
//! set reference between shape instances from different assemblyes
- Standard_EXPORT Standard_Boolean ReadSHUOs (const Handle(XSControl_WorkSession)& WS, Handle(TDocStd_Document)& doc, const STEPCAFControl_DataMapOfPDExternFile& PDFileMap, const XCAFDoc_DataMapOfShapeLabel& ShapeLabelMap) const;
+ Standard_EXPORT Standard_Boolean ReadSHUOs (const Handle(XSControl_WorkSession)& WS, Handle(TDocStd_Document)& doc, const STEPCAFControl_DataMapOfPDExternFile& PDFileMap) const;
//! Reads D> for instances defined in the STEP model and
//! set reference between shape instances from different assemblyes
//! expands their correspondent Labels in XDE Document so that
//! to have a dedicated sub-Label for each sub-shape coming
//! with associated name in its STEP Representation Item.
- Standard_EXPORT void ExpandSubShapes (const Handle(XCAFDoc_ShapeTool)& theShapeTool, const XCAFDoc_DataMapOfShapeLabel& theShapeLabelMap, const STEPCAFControl_DataMapOfShapePD& theShapePDMap) const;
+ Standard_EXPORT void ExpandSubShapes (const Handle(XCAFDoc_ShapeTool)& theShapeTool, const STEPCAFControl_DataMapOfShapePD& theShapePDMap) const;
//! Expands the topological structure of Manifold Solid BRep
//! STEP entity to OCAF sub-tree. Entities having no names
STEPControl_Reader myReader;
NCollection_DataMap<TCollection_AsciiString, Handle(STEPCAFControl_ExternFile)> myFiles;
+ XCAFDoc_DataMapOfShapeLabel myMap;
Standard_Boolean myColorMode;
Standard_Boolean myNameMode;
Standard_Boolean myLayerMode;
#include <StepVisual_CameraModelD3MultiClippingUnion.hxx>
#include <StepVisual_AnnotationCurveOccurrenceAndGeomReprItem.hxx>
+// Added for kinematics implementation
+#include <StepRepr_RepresentationContextReference.hxx>
+#include <StepRepr_RepresentationReference.hxx>
+#include <StepGeom_SuParameters.hxx>
+#include <StepKinematics_RotationAboutDirection.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepKinematics_ActuatedKinematicPair.hxx>
+#include <StepKinematics_ContextDependentKinematicLinkRepresentation.hxx>
+#include <StepKinematics_CylindricalPair.hxx>
+#include <StepKinematics_CylindricalPairValue.hxx>
+#include <StepKinematics_CylindricalPairWithRange.hxx>
+#include <StepKinematics_FullyConstrainedPair.hxx>
+#include <StepKinematics_GearPair.hxx>
+#include <StepKinematics_GearPairValue.hxx>
+#include <StepKinematics_GearPairWithRange.hxx>
+#include <StepKinematics_HomokineticPair.hxx>
+#include <StepKinematics_KinematicLink.hxx>
+#include <StepKinematics_KinematicLinkRepresentationAssociation.hxx>
+#include <StepKinematics_KinematicPropertyMechanismRepresentation.hxx>
+#include <StepKinematics_KinematicTopologyDirectedStructure.hxx>
+#include <StepKinematics_KinematicTopologyNetworkStructure.hxx>
+#include <StepKinematics_KinematicTopologyStructure.hxx>
+#include <StepKinematics_LinearFlexibleAndPinionPair.hxx>
+#include <StepKinematics_LinearFlexibleAndPlanarCurvePair.hxx>
+#include <StepKinematics_LinearFlexibleLinkRepresentation.hxx>
+#include <StepKinematics_LowOrderKinematicPair.hxx>
+#include <StepKinematics_LowOrderKinematicPairValue.hxx>
+#include <StepKinematics_LowOrderKinematicPairWithRange.hxx>
+#include <StepKinematics_MechanismRepresentation.hxx>
+#include <StepKinematics_OrientedJoint.hxx>
+#include <StepKinematics_PairRepresentationRelationship.hxx>
+#include <StepKinematics_PlanarCurvePair.hxx>
+#include <StepKinematics_PlanarCurvePairRange.hxx>
+#include <StepKinematics_PlanarPair.hxx>
+#include <StepKinematics_PlanarPairValue.hxx>
+#include <StepKinematics_PlanarPairWithRange.hxx>
+#include <StepKinematics_PointOnPlanarCurvePair.hxx>
+#include <StepKinematics_PointOnPlanarCurvePairValue.hxx>
+#include <StepKinematics_PointOnPlanarCurvePairWithRange.hxx>
+#include <StepKinematics_PointOnSurfacePair.hxx>
+#include <StepKinematics_PointOnSurfacePairValue.hxx>
+#include <StepKinematics_PointOnSurfacePairWithRange.hxx>
+#include <StepKinematics_PrismaticPair.hxx>
+#include <StepKinematics_PrismaticPairValue.hxx>
+#include <StepKinematics_PrismaticPairWithRange.hxx>
+#include <StepKinematics_ProductDefinitionKinematics.hxx>
+#include <StepKinematics_ProductDefinitionRelationshipKinematics.hxx>
+#include <StepKinematics_RackAndPinionPair.hxx>
+#include <StepKinematics_RackAndPinionPairValue.hxx>
+#include <StepKinematics_RackAndPinionPairWithRange.hxx>
+#include <StepKinematics_RevolutePair.hxx>
+#include <StepKinematics_RevolutePairValue.hxx>
+#include <StepKinematics_RevolutePairWithRange.hxx>
+#include <StepKinematics_RigidLinkRepresentation.hxx>
+#include <StepKinematics_RollingCurvePair.hxx>
+#include <StepKinematics_RollingCurvePairValue.hxx>
+#include <StepKinematics_RollingSurfacePair.hxx>
+#include <StepKinematics_RollingSurfacePairValue.hxx>
+#include <StepKinematics_ScrewPair.hxx>
+#include <StepKinematics_ScrewPairValue.hxx>
+#include <StepKinematics_ScrewPairWithRange.hxx>
+#include <StepKinematics_SlidingCurvePair.hxx>
+#include <StepKinematics_SlidingCurvePairValue.hxx>
+#include <StepKinematics_SlidingSurfacePair.hxx>
+#include <StepKinematics_SlidingSurfacePairValue.hxx>
+#include <StepKinematics_SphericalPair.hxx>
+#include <StepKinematics_SphericalPairValue.hxx>
+#include <StepKinematics_SphericalPairWithPin.hxx>
+#include <StepKinematics_SphericalPairWithPinAndRange.hxx>
+#include <StepKinematics_SphericalPairWithRange.hxx>
+#include <StepKinematics_SurfacePairWithRange.hxx>
+#include <StepKinematics_UnconstrainedPair.hxx>
+#include <StepKinematics_UnconstrainedPairValue.hxx>
+#include <StepKinematics_UniversalPair.hxx>
+#include <StepKinematics_UniversalPairValue.hxx>
+#include <StepKinematics_UniversalPairWithRange.hxx>
+#include <StepKinematics_ActuatedKinPairAndOrderKinPair.hxx>
+#include <StepKinematics_MechanismStateRepresentation.hxx>
+
#include <StepVisual_SurfaceStyleTransparent.hxx>
#include <StepVisual_SurfaceStyleReflectanceAmbient.hxx>
#include <StepVisual_SurfaceStyleRendering.hxx>
#include <StepVisual_SurfaceStyleRenderingWithProperties.hxx>
static int THE_StepAP214_Protocol_init = 0;
-static Interface_DataMapOfTransientInteger types(800);
+static Interface_DataMapOfTransientInteger types(803);
//=======================================================================
//function : StepAP214_Protocol
types.Bind (STANDARD_TYPE(StepVisual_SurfaceStyleReflectanceAmbient), 721);
types.Bind (STANDARD_TYPE(StepVisual_SurfaceStyleRendering), 722);
types.Bind (STANDARD_TYPE(StepVisual_SurfaceStyleRenderingWithProperties), 723);
+
+ // Added for kinematics implementation
+ types.Bind(STANDARD_TYPE(StepRepr_RepresentationContextReference), 724);
+ types.Bind(STANDARD_TYPE(StepRepr_RepresentationReference), 725);
+ types.Bind(STANDARD_TYPE(StepGeom_SuParameters), 726);
+ types.Bind(STANDARD_TYPE(StepKinematics_RotationAboutDirection), 727);
+ types.Bind(STANDARD_TYPE(StepKinematics_KinematicJoint), 728);
+ types.Bind(STANDARD_TYPE(StepKinematics_ActuatedKinematicPair), 729);
+ types.Bind(STANDARD_TYPE(StepKinematics_ContextDependentKinematicLinkRepresentation), 730);
+ types.Bind(STANDARD_TYPE(StepKinematics_CylindricalPair), 731);
+ types.Bind(STANDARD_TYPE(StepKinematics_CylindricalPairValue), 732);
+ types.Bind(STANDARD_TYPE(StepKinematics_CylindricalPairWithRange), 733);
+ types.Bind(STANDARD_TYPE(StepKinematics_FullyConstrainedPair), 734);
+ types.Bind(STANDARD_TYPE(StepKinematics_GearPair), 735);
+ types.Bind(STANDARD_TYPE(StepKinematics_GearPairValue), 736);
+ types.Bind(STANDARD_TYPE(StepKinematics_GearPairWithRange), 737);
+ types.Bind(STANDARD_TYPE(StepKinematics_HomokineticPair), 738);
+ types.Bind(STANDARD_TYPE(StepKinematics_KinematicLink), 739);
+ types.Bind(STANDARD_TYPE(StepKinematics_KinematicLinkRepresentationAssociation), 740);
+ types.Bind(STANDARD_TYPE(StepKinematics_KinematicPropertyMechanismRepresentation), 741);
+ types.Bind(STANDARD_TYPE(StepKinematics_KinematicTopologyStructure), 742);
+ types.Bind(STANDARD_TYPE(StepKinematics_LowOrderKinematicPair), 743);
+ types.Bind(STANDARD_TYPE(StepKinematics_LowOrderKinematicPairValue), 744);
+ types.Bind(STANDARD_TYPE(StepKinematics_LowOrderKinematicPairWithRange), 745);
+ types.Bind(STANDARD_TYPE(StepKinematics_MechanismRepresentation), 746);
+ types.Bind(STANDARD_TYPE(StepKinematics_OrientedJoint), 747);
+ types.Bind(STANDARD_TYPE(StepKinematics_PlanarCurvePair), 748);
+ types.Bind(STANDARD_TYPE(StepKinematics_PlanarCurvePairRange), 749);
+ types.Bind(STANDARD_TYPE(StepKinematics_PlanarPair), 750);
+ types.Bind(STANDARD_TYPE(StepKinematics_PlanarPairValue), 751);
+ types.Bind(STANDARD_TYPE(StepKinematics_PlanarPairWithRange), 752);
+ types.Bind(STANDARD_TYPE(StepKinematics_PointOnPlanarCurvePair), 753);
+ types.Bind(STANDARD_TYPE(StepKinematics_PointOnPlanarCurvePairValue), 754);
+ types.Bind(STANDARD_TYPE(StepKinematics_PointOnPlanarCurvePairWithRange), 755);
+ types.Bind(STANDARD_TYPE(StepKinematics_PointOnSurfacePair), 756);
+ types.Bind(STANDARD_TYPE(StepKinematics_PointOnSurfacePairValue), 757);
+ types.Bind(STANDARD_TYPE(StepKinematics_PointOnSurfacePairWithRange), 758);
+ types.Bind(STANDARD_TYPE(StepKinematics_PrismaticPair), 759);
+ types.Bind(STANDARD_TYPE(StepKinematics_PrismaticPairValue), 760);
+ types.Bind(STANDARD_TYPE(StepKinematics_PrismaticPairWithRange), 761);
+ types.Bind(STANDARD_TYPE(StepKinematics_ProductDefinitionKinematics), 762);
+ types.Bind(STANDARD_TYPE(StepKinematics_ProductDefinitionRelationshipKinematics), 763);
+ types.Bind(STANDARD_TYPE(StepKinematics_RackAndPinionPair), 764);
+ types.Bind(STANDARD_TYPE(StepKinematics_RackAndPinionPairValue), 765);
+ types.Bind(STANDARD_TYPE(StepKinematics_RackAndPinionPairWithRange), 766);
+ types.Bind(STANDARD_TYPE(StepKinematics_RevolutePair), 767);
+ types.Bind(STANDARD_TYPE(StepKinematics_RevolutePairValue), 768);
+ types.Bind(STANDARD_TYPE(StepKinematics_RevolutePairWithRange), 769);
+ types.Bind(STANDARD_TYPE(StepKinematics_RollingCurvePair), 770);
+ types.Bind(STANDARD_TYPE(StepKinematics_RollingCurvePairValue), 771);
+ types.Bind(STANDARD_TYPE(StepKinematics_RollingSurfacePair), 772);
+ types.Bind(STANDARD_TYPE(StepKinematics_RollingSurfacePairValue), 773);
+ types.Bind(STANDARD_TYPE(StepKinematics_ScrewPair), 774);
+ types.Bind(STANDARD_TYPE(StepKinematics_ScrewPairValue), 775);
+ types.Bind(STANDARD_TYPE(StepKinematics_ScrewPairWithRange), 776);
+ types.Bind(STANDARD_TYPE(StepKinematics_SlidingCurvePair), 777);
+ types.Bind(STANDARD_TYPE(StepKinematics_SlidingCurvePairValue), 778);
+ types.Bind(STANDARD_TYPE(StepKinematics_SlidingSurfacePair), 779);
+ types.Bind(STANDARD_TYPE(StepKinematics_SlidingSurfacePairValue), 780);
+ types.Bind(STANDARD_TYPE(StepKinematics_SphericalPair), 781);
+ types.Bind(STANDARD_TYPE(StepKinematics_SphericalPairValue), 782);
+ types.Bind(STANDARD_TYPE(StepKinematics_SphericalPairWithPin), 783);
+ types.Bind(STANDARD_TYPE(StepKinematics_SphericalPairWithPinAndRange), 784);
+ types.Bind(STANDARD_TYPE(StepKinematics_SphericalPairWithRange), 785);
+ types.Bind(STANDARD_TYPE(StepKinematics_SurfacePairWithRange), 786);
+ types.Bind(STANDARD_TYPE(StepKinematics_UnconstrainedPair), 787);
+ types.Bind(STANDARD_TYPE(StepKinematics_UnconstrainedPairValue), 788);
+ types.Bind(STANDARD_TYPE(StepKinematics_UniversalPair), 789);
+ types.Bind(STANDARD_TYPE(StepKinematics_UniversalPairValue), 790);
+ types.Bind(STANDARD_TYPE(StepKinematics_UniversalPairWithRange), 791);
+ types.Bind(STANDARD_TYPE(StepKinematics_PairRepresentationRelationship), 792);
+ types.Bind(STANDARD_TYPE(StepKinematics_RigidLinkRepresentation), 793);
+ types.Bind(STANDARD_TYPE(StepKinematics_KinematicTopologyDirectedStructure), 794);
+ types.Bind(STANDARD_TYPE(StepKinematics_KinematicTopologyNetworkStructure), 795);
+ types.Bind(STANDARD_TYPE(StepKinematics_LinearFlexibleAndPinionPair), 796);
+ types.Bind(STANDARD_TYPE(StepKinematics_LinearFlexibleAndPlanarCurvePair), 797);
+ types.Bind(STANDARD_TYPE(StepKinematics_LinearFlexibleLinkRepresentation), 798);
+ types.Bind(STANDARD_TYPE(StepKinematics_ActuatedKinPairAndOrderKinPair), 800);
+ types.Bind(STANDARD_TYPE(StepKinematics_MechanismStateRepresentation), 801);
}
StepGeom_SeamCurve.hxx
StepGeom_SphericalSurface.cxx
StepGeom_SphericalSurface.hxx
+StepGeom_SuParameters.cxx
+StepGeom_SuParameters.hxx
StepGeom_Surface.cxx
StepGeom_Surface.hxx
StepGeom_SurfaceBoundary.cxx
--- /dev/null
+// Created on : Sat May 02 12:41:14 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepGeom_SuParameters.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepGeom_SuParameters, StepGeom_GeometricRepresentationItem)
+
+//=======================================================================
+//function : StepGeom_SuParameters
+//purpose :
+//=======================================================================
+
+StepGeom_SuParameters::StepGeom_SuParameters ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepGeom_SuParameters::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Standard_Real theA,
+ const Standard_Real theAlpha,
+ const Standard_Real theB,
+ const Standard_Real theBeta,
+ const Standard_Real theC,
+ const Standard_Real theGamma)
+{
+ StepGeom_GeometricRepresentationItem::Init(theRepresentationItem_Name);
+
+ myA = theA;
+
+ myAlpha = theAlpha;
+
+ myB = theB;
+
+ myBeta = theBeta;
+
+ myC = theC;
+
+ myGamma = theGamma;
+}
+
+//=======================================================================
+//function : A
+//purpose :
+//=======================================================================
+
+Standard_Real StepGeom_SuParameters::A () const
+{
+ return myA;
+}
+
+//=======================================================================
+//function : SetA
+//purpose :
+//=======================================================================
+
+void StepGeom_SuParameters::SetA (const Standard_Real theA)
+{
+ myA = theA;
+}
+
+//=======================================================================
+//function : Alpha
+//purpose :
+//=======================================================================
+
+Standard_Real StepGeom_SuParameters::Alpha () const
+{
+ return myAlpha;
+}
+
+//=======================================================================
+//function : SetAlpha
+//purpose :
+//=======================================================================
+
+void StepGeom_SuParameters::SetAlpha (const Standard_Real theAlpha)
+{
+ myAlpha = theAlpha;
+}
+
+//=======================================================================
+//function : B
+//purpose :
+//=======================================================================
+
+Standard_Real StepGeom_SuParameters::B () const
+{
+ return myB;
+}
+
+//=======================================================================
+//function : SetB
+//purpose :
+//=======================================================================
+
+void StepGeom_SuParameters::SetB (const Standard_Real theB)
+{
+ myB = theB;
+}
+
+//=======================================================================
+//function : Beta
+//purpose :
+//=======================================================================
+
+Standard_Real StepGeom_SuParameters::Beta () const
+{
+ return myBeta;
+}
+
+//=======================================================================
+//function : SetBeta
+//purpose :
+//=======================================================================
+
+void StepGeom_SuParameters::SetBeta (const Standard_Real theBeta)
+{
+ myBeta = theBeta;
+}
+
+//=======================================================================
+//function : C
+//purpose :
+//=======================================================================
+
+Standard_Real StepGeom_SuParameters::C () const
+{
+ return myC;
+}
+
+//=======================================================================
+//function : SetC
+//purpose :
+//=======================================================================
+
+void StepGeom_SuParameters::SetC (const Standard_Real theC)
+{
+ myC = theC;
+}
+
+//=======================================================================
+//function : Gamma
+//purpose :
+//=======================================================================
+
+Standard_Real StepGeom_SuParameters::Gamma () const
+{
+ return myGamma;
+}
+
+//=======================================================================
+//function : SetGamma
+//purpose :
+//=======================================================================
+
+void StepGeom_SuParameters::SetGamma (const Standard_Real theGamma)
+{
+ myGamma = theGamma;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:14 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepGeom_SuParameters_HeaderFile_
+#define _StepGeom_SuParameters_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepGeom_GeometricRepresentationItem.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+
+DEFINE_STANDARD_HANDLE(StepGeom_SuParameters, StepGeom_GeometricRepresentationItem)
+
+//! Representation of STEP entity SuParameters
+class StepGeom_SuParameters : public StepGeom_GeometricRepresentationItem
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepGeom_SuParameters();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Standard_Real theA,
+ const Standard_Real theAlpha,
+ const Standard_Real theB,
+ const Standard_Real theBeta,
+ const Standard_Real theC,
+ const Standard_Real theGamma);
+
+ //! Returns field A
+ Standard_EXPORT Standard_Real A() const;
+ //! Sets field A
+ Standard_EXPORT void SetA (const Standard_Real theA);
+
+ //! Returns field Alpha
+ Standard_EXPORT Standard_Real Alpha() const;
+ //! Sets field Alpha
+ Standard_EXPORT void SetAlpha (const Standard_Real theAlpha);
+
+ //! Returns field B
+ Standard_EXPORT Standard_Real B() const;
+ //! Sets field B
+ Standard_EXPORT void SetB (const Standard_Real theB);
+
+ //! Returns field Beta
+ Standard_EXPORT Standard_Real Beta() const;
+ //! Sets field Beta
+ Standard_EXPORT void SetBeta (const Standard_Real theBeta);
+
+ //! Returns field C
+ Standard_EXPORT Standard_Real C() const;
+ //! Sets field C
+ Standard_EXPORT void SetC (const Standard_Real theC);
+
+ //! Returns field Gamma
+ Standard_EXPORT Standard_Real Gamma() const;
+ //! Sets field Gamma
+ Standard_EXPORT void SetGamma (const Standard_Real theGamma);
+
+DEFINE_STANDARD_RTTIEXT(StepGeom_SuParameters, StepGeom_GeometricRepresentationItem)
+
+private:
+ Standard_Real myA;
+ Standard_Real myAlpha;
+ Standard_Real myB;
+ Standard_Real myBeta;
+ Standard_Real myC;
+ Standard_Real myGamma;
+
+};
+#endif // _StepGeom_SuParameters_HeaderFile_
--- /dev/null
+StepKinematics_ActuatedDirection.hxx
+StepKinematics_ActuatedKinematicPair.cxx
+StepKinematics_ActuatedKinematicPair.hxx
+StepKinematics_ContextDependentKinematicLinkRepresentation.cxx
+StepKinematics_ContextDependentKinematicLinkRepresentation.hxx
+StepKinematics_CylindricalPair.cxx
+StepKinematics_CylindricalPair.hxx
+StepKinematics_CylindricalPairValue.cxx
+StepKinematics_CylindricalPairValue.hxx
+StepKinematics_CylindricalPairWithRange.cxx
+StepKinematics_CylindricalPairWithRange.hxx
+StepKinematics_FullyConstrainedPair.cxx
+StepKinematics_FullyConstrainedPair.hxx
+StepKinematics_GearPair.cxx
+StepKinematics_GearPair.hxx
+StepKinematics_GearPairValue.cxx
+StepKinematics_GearPairValue.hxx
+StepKinematics_GearPairWithRange.cxx
+StepKinematics_GearPairWithRange.hxx
+StepKinematics_HighOrderKinematicPair.cxx
+StepKinematics_HighOrderKinematicPair.hxx
+StepKinematics_HomokineticPair.cxx
+StepKinematics_HomokineticPair.hxx
+StepKinematics_KinematicJoint.cxx
+StepKinematics_KinematicJoint.hxx
+StepKinematics_KinematicLink.cxx
+StepKinematics_KinematicLink.hxx
+StepKinematics_KinematicLinkRepresentation.cxx
+StepKinematics_KinematicLinkRepresentation.hxx
+StepKinematics_KinematicLinkRepresentationAssociation.cxx
+StepKinematics_KinematicLinkRepresentationAssociation.hxx
+StepKinematics_KinematicPair.cxx
+StepKinematics_KinematicPair.hxx
+StepKinematics_ActuatedKinPairAndOrderKinPair.cxx
+StepKinematics_ActuatedKinPairAndOrderKinPair.hxx
+StepKinematics_KinematicPropertyDefinitionRepresentation.cxx
+StepKinematics_KinematicPropertyDefinitionRepresentation.hxx
+StepKinematics_KinematicPropertyMechanismRepresentation.cxx
+StepKinematics_KinematicPropertyMechanismRepresentation.hxx
+StepKinematics_KinematicTopologyStructure.cxx
+StepKinematics_KinematicTopologyStructure.hxx
+StepKinematics_LinearFlexibleAndPinionPair.cxx
+StepKinematics_LinearFlexibleAndPinionPair.hxx
+StepKinematics_LinearFlexibleAndPlanarCurvePair.cxx
+StepKinematics_LinearFlexibleAndPlanarCurvePair.hxx
+StepKinematics_LinearFlexibleLinkRepresentation.cxx
+StepKinematics_LinearFlexibleLinkRepresentation.hxx
+StepKinematics_LowOrderKinematicPair.cxx
+StepKinematics_LowOrderKinematicPair.hxx
+StepKinematics_LowOrderKinematicPairValue.cxx
+StepKinematics_LowOrderKinematicPairValue.hxx
+StepKinematics_LowOrderKinematicPairWithMotionCoupling.cxx
+StepKinematics_LowOrderKinematicPairWithMotionCoupling.hxx
+StepKinematics_LowOrderKinematicPairWithRange.cxx
+StepKinematics_LowOrderKinematicPairWithRange.hxx
+StepKinematics_MechanismRepresentation.cxx
+StepKinematics_MechanismRepresentation.hxx
+StepKinematics_MechanismStateRepresentation.cxx
+StepKinematics_MechanismStateRepresentation.hxx
+StepKinematics_OrientedJoint.cxx
+StepKinematics_OrientedJoint.hxx
+StepKinematics_PairRepresentationRelationship.cxx
+StepKinematics_PairRepresentationRelationship.hxx
+StepKinematics_PairValue.cxx
+StepKinematics_PairValue.hxx
+StepKinematics_PlanarCurvePair.cxx
+StepKinematics_PlanarCurvePair.hxx
+StepKinematics_PlanarCurvePairRange.cxx
+StepKinematics_PlanarCurvePairRange.hxx
+StepKinematics_PlanarPair.cxx
+StepKinematics_PlanarPair.hxx
+StepKinematics_PlanarPairValue.cxx
+StepKinematics_PlanarPairValue.hxx
+StepKinematics_PlanarPairWithRange.cxx
+StepKinematics_PlanarPairWithRange.hxx
+StepKinematics_PointOnPlanarCurvePair.cxx
+StepKinematics_PointOnPlanarCurvePair.hxx
+StepKinematics_PointOnPlanarCurvePairValue.cxx
+StepKinematics_PointOnPlanarCurvePairValue.hxx
+StepKinematics_PointOnPlanarCurvePairWithRange.cxx
+StepKinematics_PointOnPlanarCurvePairWithRange.hxx
+StepKinematics_PointOnSurfacePair.cxx
+StepKinematics_PointOnSurfacePair.hxx
+StepKinematics_PointOnSurfacePairValue.cxx
+StepKinematics_PointOnSurfacePairValue.hxx
+StepKinematics_PointOnSurfacePairWithRange.cxx
+StepKinematics_PointOnSurfacePairWithRange.hxx
+StepKinematics_PrismaticPair.cxx
+StepKinematics_PrismaticPair.hxx
+StepKinematics_PrismaticPairValue.cxx
+StepKinematics_PrismaticPairValue.hxx
+StepKinematics_PrismaticPairWithRange.cxx
+StepKinematics_PrismaticPairWithRange.hxx
+StepKinematics_ProductDefinitionKinematics.cxx
+StepKinematics_ProductDefinitionKinematics.hxx
+StepKinematics_ProductDefinitionRelationshipKinematics.cxx
+StepKinematics_ProductDefinitionRelationshipKinematics.hxx
+StepKinematics_RackAndPinionPair.cxx
+StepKinematics_RackAndPinionPair.hxx
+StepKinematics_RackAndPinionPairValue.cxx
+StepKinematics_RackAndPinionPairValue.hxx
+StepKinematics_RackAndPinionPairWithRange.cxx
+StepKinematics_RackAndPinionPairWithRange.hxx
+StepKinematics_RevolutePair.cxx
+StepKinematics_RevolutePair.hxx
+StepKinematics_RevolutePairValue.cxx
+StepKinematics_RevolutePairValue.hxx
+StepKinematics_RevolutePairWithRange.cxx
+StepKinematics_RevolutePairWithRange.hxx
+StepKinematics_RigidLinkRepresentation.cxx
+StepKinematics_RigidLinkRepresentation.hxx
+StepKinematics_RigidPlacement.cxx
+StepKinematics_RigidPlacement.hxx
+StepKinematics_RollingCurvePair.cxx
+StepKinematics_RollingCurvePair.hxx
+StepKinematics_RollingCurvePairValue.cxx
+StepKinematics_RollingCurvePairValue.hxx
+StepKinematics_RollingSurfacePair.cxx
+StepKinematics_RollingSurfacePair.hxx
+StepKinematics_RollingSurfacePairValue.cxx
+StepKinematics_RollingSurfacePairValue.hxx
+StepKinematics_RotationAboutDirection.cxx
+StepKinematics_RotationAboutDirection.hxx
+StepKinematics_ScrewPair.cxx
+StepKinematics_ScrewPair.hxx
+StepKinematics_ScrewPairValue.cxx
+StepKinematics_ScrewPairValue.hxx
+StepKinematics_ScrewPairWithRange.cxx
+StepKinematics_ScrewPairWithRange.hxx
+StepKinematics_SlidingCurvePair.cxx
+StepKinematics_SlidingCurvePair.hxx
+StepKinematics_SlidingCurvePairValue.cxx
+StepKinematics_SlidingCurvePairValue.hxx
+StepKinematics_SlidingSurfacePair.cxx
+StepKinematics_SlidingSurfacePair.hxx
+StepKinematics_SlidingSurfacePairValue.cxx
+StepKinematics_SlidingSurfacePairValue.hxx
+StepKinematics_SpatialRotation.cxx
+StepKinematics_SpatialRotation.hxx
+StepKinematics_SphericalPair.cxx
+StepKinematics_SphericalPair.hxx
+StepKinematics_SphericalPairSelect.cxx
+StepKinematics_SphericalPairSelect.hxx
+StepKinematics_SphericalPairValue.cxx
+StepKinematics_SphericalPairValue.hxx
+StepKinematics_SphericalPairWithPin.cxx
+StepKinematics_SphericalPairWithPin.hxx
+StepKinematics_SphericalPairWithPinAndRange.cxx
+StepKinematics_SphericalPairWithPinAndRange.hxx
+StepKinematics_SphericalPairWithRange.cxx
+StepKinematics_SphericalPairWithRange.hxx
+StepKinematics_SurfacePair.cxx
+StepKinematics_SurfacePair.hxx
+StepKinematics_SurfacePairWithRange.cxx
+StepKinematics_SurfacePairWithRange.hxx
+StepKinematics_KinematicTopologyDirectedStructure.cxx
+StepKinematics_KinematicTopologyDirectedStructure.hxx
+StepKinematics_KinematicTopologyNetworkStructure.cxx
+StepKinematics_KinematicTopologyNetworkStructure.hxx
+StepKinematics_KinematicTopologyRepresentationSelect.cxx
+StepKinematics_KinematicTopologyRepresentationSelect.hxx
+StepKinematics_UnconstrainedPair.cxx
+StepKinematics_UnconstrainedPair.hxx
+StepKinematics_UnconstrainedPairValue.cxx
+StepKinematics_UnconstrainedPairValue.hxx
+StepKinematics_UniversalPair.cxx
+StepKinematics_UniversalPair.hxx
+StepKinematics_UniversalPairValue.cxx
+StepKinematics_UniversalPairValue.hxx
+StepKinematics_UniversalPairWithRange.cxx
+StepKinematics_UniversalPairWithRange.hxx
\ No newline at end of file
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_ActuatedDirection_HeaderFile
+#define _StepKinematics_ActuatedDirection_HeaderFile
+
+enum StepKinematics_ActuatedDirection
+{
+ StepKinematics_adBidirectional,
+ StepKinematics_adPositiveOnly,
+ StepKinematics_adNegativeOnly,
+ StepKinematics_adNotActuated
+};
+#endif // _StepKinematics_ActuatedDirection_HeaderFile
--- /dev/null
+// Created on: 2020-05-26
+// Created by: PASUKHIN DMITRY
+// Copyright (c) 2020 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_ActuatedKinPairAndOrderKinPair.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <StepKinematics_ActuatedKinematicPair.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_ActuatedKinPairAndOrderKinPair, StepKinematics_KinematicPair)
+
+//=======================================================================
+//function : StepKinematics_ActuatedKinPairAndOrderKinPair
+//purpose :
+//=======================================================================
+StepKinematics_ActuatedKinPairAndOrderKinPair::StepKinematics_ActuatedKinPairAndOrderKinPair()
+{}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_ActuatedKinPairAndOrderKinPair::Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theJoint,
+ const Handle(StepKinematics_ActuatedKinematicPair)& theActuatedKinematicPair,
+ const Handle(StepKinematics_KinematicPair)& theOrderKinematicPair)
+{
+ StepKinematics_KinematicPair::Init(theRepresentationItem_Name,
+ theItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2,
+ theJoint);
+ SetActuatedKinematicPair(theActuatedKinematicPair);
+ SetOrderKinematicPair(theOrderKinematicPair);
+}
--- /dev/null
+// Created on: 2020-05-26
+// Created by: PASUKHIN DMITRY
+// Copyright (c) 2020 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_ActuatedKinPairAndOrderKinPair_HeaderFile_
+#define _StepKinematics_ActuatedKinPairAndOrderKinPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <Standard_Transient.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <TColStd_HArray1OfReal.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+class StepRepr_RepresentationItem;
+class StepKinematics_ActuatedKinematicPair;
+class StepKinematics_ActuatedKinPairAndOrderKinPair;
+
+DEFINE_STANDARD_HANDLE(StepKinematics_ActuatedKinPairAndOrderKinPair, StepKinematics_KinematicPair)
+
+//! Representation of STEP entity ActuatedKinPairAndOrderKinPair
+class StepKinematics_ActuatedKinPairAndOrderKinPair : public StepKinematics_KinematicPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_ActuatedKinPairAndOrderKinPair();
+
+
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theJoint,
+ const Handle(StepKinematics_ActuatedKinematicPair)& theActuatedKinematicPair,
+ const Handle(StepKinematics_KinematicPair)& theOrderKinematicPair);
+
+ inline void SetActuatedKinematicPair(const Handle(StepKinematics_ActuatedKinematicPair)& aKP) {
+ myActuatedKinematicPair = aKP;
+ }
+
+ inline Handle(StepKinematics_ActuatedKinematicPair) GetActuatedKinematicPair() const {
+ return myActuatedKinematicPair;
+ }
+ inline void SetOrderKinematicPair(const Handle(StepKinematics_KinematicPair)& aKP) {
+ myOrderKinematicPair = aKP;
+ }
+
+ inline Handle(StepKinematics_KinematicPair) GetOrderKinematicPair() const {
+ return myOrderKinematicPair;
+ }
+
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_ActuatedKinPairAndOrderKinPair, StepKinematics_KinematicPair)
+
+private:
+ Handle(StepKinematics_ActuatedKinematicPair) myActuatedKinematicPair;
+ Handle(StepKinematics_KinematicPair) myOrderKinematicPair;
+};
+#endif // StepKinematics_ActuatedKinPairAndOrderKinPair
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_ActuatedKinematicPair.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_ActuatedKinematicPair, StepKinematics_KinematicPair)
+
+//=======================================================================
+//function : StepKinematics_ActuatedKinematicPair
+//purpose :
+//=======================================================================
+StepKinematics_ActuatedKinematicPair::StepKinematics_ActuatedKinematicPair ()
+{
+ defTX = Standard_False;
+ defTY = Standard_False;
+ defTZ = Standard_False;
+ defRX = Standard_False;
+ defRY = Standard_False;
+ defRZ = Standard_False;
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_ActuatedKinematicPair::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Boolean hasTX,
+ const StepKinematics_ActuatedDirection theTX,
+ const Standard_Boolean hasTY,
+ const StepKinematics_ActuatedDirection theTY,
+ const Standard_Boolean hasTZ,
+ const StepKinematics_ActuatedDirection theTZ,
+ const Standard_Boolean hasRX,
+ const StepKinematics_ActuatedDirection theRX,
+ const Standard_Boolean hasRY,
+ const StepKinematics_ActuatedDirection theRY,
+ const Standard_Boolean hasRZ,
+ const StepKinematics_ActuatedDirection theRZ)
+{
+ StepKinematics_KinematicPair::Init(theRepresentationItem_Name,
+ theItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2,
+ theKinematicPair_Joint);
+
+ defTX = hasTX;
+ if (defTX) {
+ myTX = theTX;
+ }
+ else myTX = StepKinematics_ActuatedDirection();
+
+ defTY = hasTY;
+ if (defTY) {
+ myTY = theTY;
+ }
+ else myTY = StepKinematics_ActuatedDirection();
+
+ defTZ = hasTZ;
+ if (defTZ) {
+ myTZ = theTZ;
+ }
+ else myTZ = StepKinematics_ActuatedDirection();
+
+ defRX = hasRX;
+ if (defRX) {
+ myRX = theRX;
+ }
+ else myRX = StepKinematics_ActuatedDirection();
+
+ defRY = hasRY;
+ if (defRY) {
+ myRY = theRY;
+ }
+ else myRY = StepKinematics_ActuatedDirection();
+
+ defRZ = hasRZ;
+ if (defRZ) {
+ myRZ = theRZ;
+ }
+ else myRZ = StepKinematics_ActuatedDirection();
+}
+
+//=======================================================================
+//function : TX
+//purpose :
+//=======================================================================
+StepKinematics_ActuatedDirection StepKinematics_ActuatedKinematicPair::TX () const
+{
+ return myTX;
+}
+
+//=======================================================================
+//function : SetTX
+//purpose :
+//=======================================================================
+void StepKinematics_ActuatedKinematicPair::SetTX (const StepKinematics_ActuatedDirection theTX)
+{
+ myTX = theTX;
+}
+
+//=======================================================================
+//function : HasTX
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_ActuatedKinematicPair::HasTX () const
+{
+ return defTX;
+}
+
+//=======================================================================
+//function : TY
+//purpose :
+//=======================================================================
+StepKinematics_ActuatedDirection StepKinematics_ActuatedKinematicPair::TY () const
+{
+ return myTY;
+}
+
+//=======================================================================
+//function : SetTY
+//purpose :
+//=======================================================================
+void StepKinematics_ActuatedKinematicPair::SetTY (const StepKinematics_ActuatedDirection theTY)
+{
+ myTY = theTY;
+}
+
+//=======================================================================
+//function : HasTY
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_ActuatedKinematicPair::HasTY () const
+{
+ return defTY;
+}
+
+//=======================================================================
+//function : TZ
+//purpose :
+//=======================================================================
+StepKinematics_ActuatedDirection StepKinematics_ActuatedKinematicPair::TZ () const
+{
+ return myTZ;
+}
+
+//=======================================================================
+//function : SetTZ
+//purpose :
+//=======================================================================
+void StepKinematics_ActuatedKinematicPair::SetTZ (const StepKinematics_ActuatedDirection theTZ)
+{
+ myTZ = theTZ;
+}
+
+//=======================================================================
+//function : HasTZ
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_ActuatedKinematicPair::HasTZ () const
+{
+ return defTZ;
+}
+
+//=======================================================================
+//function : RX
+//purpose :
+//=======================================================================
+StepKinematics_ActuatedDirection StepKinematics_ActuatedKinematicPair::RX () const
+{
+ return myRX;
+}
+
+//=======================================================================
+//function : SetRX
+//purpose :
+//=======================================================================
+void StepKinematics_ActuatedKinematicPair::SetRX (const StepKinematics_ActuatedDirection theRX)
+{
+ myRX = theRX;
+}
+
+//=======================================================================
+//function : HasRX
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_ActuatedKinematicPair::HasRX () const
+{
+ return defRX;
+}
+
+//=======================================================================
+//function : RY
+//purpose :
+//=======================================================================
+StepKinematics_ActuatedDirection StepKinematics_ActuatedKinematicPair::RY () const
+{
+ return myRY;
+}
+
+//=======================================================================
+//function : SetRY
+//purpose :
+//=======================================================================
+void StepKinematics_ActuatedKinematicPair::SetRY (const StepKinematics_ActuatedDirection theRY)
+{
+ myRY = theRY;
+}
+
+//=======================================================================
+//function : HasRY
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_ActuatedKinematicPair::HasRY () const
+{
+ return defRY;
+}
+
+//=======================================================================
+//function : RZ
+//purpose :
+//=======================================================================
+StepKinematics_ActuatedDirection StepKinematics_ActuatedKinematicPair::RZ () const
+{
+ return myRZ;
+}
+
+//=======================================================================
+//function : SetRZ
+//purpose :
+//=======================================================================
+void StepKinematics_ActuatedKinematicPair::SetRZ (const StepKinematics_ActuatedDirection theRZ)
+{
+ myRZ = theRZ;
+}
+
+//=======================================================================
+//function : HasRZ
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_ActuatedKinematicPair::HasRZ () const
+{
+ return defRZ;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_ActuatedKinematicPair_HeaderFile_
+#define _StepKinematics_ActuatedKinematicPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepKinematics_ActuatedDirection.hxx>
+#include <StepKinematics_ActuatedDirection.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_ActuatedKinematicPair, StepKinematics_KinematicPair)
+
+//! Representation of STEP entity ActuatedKinematicPair
+class StepKinematics_ActuatedKinematicPair : public StepKinematics_KinematicPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_ActuatedKinematicPair();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Boolean hasTX,
+ const StepKinematics_ActuatedDirection theTX,
+ const Standard_Boolean hasTY,
+ const StepKinematics_ActuatedDirection theTY,
+ const Standard_Boolean hasTZ,
+ const StepKinematics_ActuatedDirection theTZ,
+ const Standard_Boolean hasRX,
+ const StepKinematics_ActuatedDirection theRX,
+ const Standard_Boolean hasRY,
+ const StepKinematics_ActuatedDirection theRY,
+ const Standard_Boolean hasRZ,
+ const StepKinematics_ActuatedDirection theRZ);
+
+ //! Returns field TX
+ Standard_EXPORT StepKinematics_ActuatedDirection TX() const;
+ //! Sets field TX
+ Standard_EXPORT void SetTX (const StepKinematics_ActuatedDirection theTX);
+ //! Returns True if optional field TX is defined
+ Standard_EXPORT Standard_Boolean HasTX() const;
+
+ //! Returns field TY
+ Standard_EXPORT StepKinematics_ActuatedDirection TY() const;
+ //! Sets field TY
+ Standard_EXPORT void SetTY (const StepKinematics_ActuatedDirection theTY);
+ //! Returns True if optional field TY is defined
+ Standard_EXPORT Standard_Boolean HasTY() const;
+
+ //! Returns field TZ
+ Standard_EXPORT StepKinematics_ActuatedDirection TZ() const;
+ //! Sets field TZ
+ Standard_EXPORT void SetTZ (const StepKinematics_ActuatedDirection theTZ);
+ //! Returns True if optional field TZ is defined
+ Standard_EXPORT Standard_Boolean HasTZ() const;
+
+ //! Returns field RX
+ Standard_EXPORT StepKinematics_ActuatedDirection RX() const;
+ //! Sets field RX
+ Standard_EXPORT void SetRX (const StepKinematics_ActuatedDirection theRX);
+ //! Returns True if optional field RX is defined
+ Standard_EXPORT Standard_Boolean HasRX() const;
+
+ //! Returns field RY
+ Standard_EXPORT StepKinematics_ActuatedDirection RY() const;
+ //! Sets field RY
+ Standard_EXPORT void SetRY (const StepKinematics_ActuatedDirection theRY);
+ //! Returns True if optional field RY is defined
+ Standard_EXPORT Standard_Boolean HasRY() const;
+
+ //! Returns field RZ
+ Standard_EXPORT StepKinematics_ActuatedDirection RZ() const;
+ //! Sets field RZ
+ Standard_EXPORT void SetRZ (const StepKinematics_ActuatedDirection theRZ);
+ //! Returns True if optional field RZ is defined
+ Standard_EXPORT Standard_Boolean HasRZ() const;
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_ActuatedKinematicPair, StepKinematics_KinematicPair)
+
+private:
+ StepKinematics_ActuatedDirection myTX; //!< optional
+ StepKinematics_ActuatedDirection myTY; //!< optional
+ StepKinematics_ActuatedDirection myTZ; //!< optional
+ StepKinematics_ActuatedDirection myRX; //!< optional
+ StepKinematics_ActuatedDirection myRY; //!< optional
+ StepKinematics_ActuatedDirection myRZ; //!< optional
+ Standard_Boolean defTX; //!< flag "is TX defined"
+ Standard_Boolean defTY; //!< flag "is TY defined"
+ Standard_Boolean defTZ; //!< flag "is TZ defined"
+ Standard_Boolean defRX; //!< flag "is RX defined"
+ Standard_Boolean defRY; //!< flag "is RY defined"
+ Standard_Boolean defRZ; //!< flag "is RZ defined"
+
+};
+#endif // _StepKinematics_ActuatedKinematicPair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_ContextDependentKinematicLinkRepresentation.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_ContextDependentKinematicLinkRepresentation, Standard_Transient)
+
+//=======================================================================
+//function : StepKinematics_ContextDependentKinematicLinkRepresentation
+//purpose :
+//=======================================================================
+StepKinematics_ContextDependentKinematicLinkRepresentation::StepKinematics_ContextDependentKinematicLinkRepresentation ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_ContextDependentKinematicLinkRepresentation::Init (const Handle(StepKinematics_KinematicLinkRepresentationAssociation)& theRepresentationRelation,
+ const Handle(StepKinematics_ProductDefinitionRelationshipKinematics)& theRepresentedProductRelation)
+{
+
+ myRepresentationRelation = theRepresentationRelation;
+
+ myRepresentedProductRelation = theRepresentedProductRelation;
+}
+
+//=======================================================================
+//function : RepresentationRelation
+//purpose :
+//=======================================================================
+Handle(StepKinematics_KinematicLinkRepresentationAssociation) StepKinematics_ContextDependentKinematicLinkRepresentation::RepresentationRelation () const
+{
+ return myRepresentationRelation;
+}
+
+//=======================================================================
+//function : SetRepresentationRelation
+//purpose :
+//=======================================================================
+void StepKinematics_ContextDependentKinematicLinkRepresentation::SetRepresentationRelation (const Handle(StepKinematics_KinematicLinkRepresentationAssociation)& theRepresentationRelation)
+{
+ myRepresentationRelation = theRepresentationRelation;
+}
+
+//=======================================================================
+//function : RepresentedProductRelation
+//purpose :
+//=======================================================================
+Handle(StepKinematics_ProductDefinitionRelationshipKinematics) StepKinematics_ContextDependentKinematicLinkRepresentation::RepresentedProductRelation () const
+{
+ return myRepresentedProductRelation;
+}
+
+//=======================================================================
+//function : SetRepresentedProductRelation
+//purpose :
+//=======================================================================
+void StepKinematics_ContextDependentKinematicLinkRepresentation::SetRepresentedProductRelation (const Handle(StepKinematics_ProductDefinitionRelationshipKinematics)& theRepresentedProductRelation)
+{
+ myRepresentedProductRelation = theRepresentedProductRelation;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_ContextDependentKinematicLinkRepresentation_HeaderFile_
+#define _StepKinematics_ContextDependentKinematicLinkRepresentation_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <Standard_Transient.hxx>
+
+#include <StepKinematics_KinematicLinkRepresentationAssociation.hxx>
+#include <StepKinematics_ProductDefinitionRelationshipKinematics.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_ContextDependentKinematicLinkRepresentation, Standard_Transient)
+
+//! Representation of STEP entity ContextDependentKinematicLinkRepresentation
+class StepKinematics_ContextDependentKinematicLinkRepresentation : public Standard_Transient
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_ContextDependentKinematicLinkRepresentation();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(StepKinematics_KinematicLinkRepresentationAssociation)& theRepresentationRelation,
+ const Handle(StepKinematics_ProductDefinitionRelationshipKinematics)& theRepresentedProductRelation);
+
+ //! Returns field RepresentationRelation
+ Standard_EXPORT Handle(StepKinematics_KinematicLinkRepresentationAssociation) RepresentationRelation() const;
+ //! Sets field RepresentationRelation
+ Standard_EXPORT void SetRepresentationRelation (const Handle(StepKinematics_KinematicLinkRepresentationAssociation)& theRepresentationRelation);
+
+ //! Returns field RepresentedProductRelation
+ Standard_EXPORT Handle(StepKinematics_ProductDefinitionRelationshipKinematics) RepresentedProductRelation() const;
+ //! Sets field RepresentedProductRelation
+ Standard_EXPORT void SetRepresentedProductRelation (const Handle(StepKinematics_ProductDefinitionRelationshipKinematics)& theRepresentedProductRelation);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_ContextDependentKinematicLinkRepresentation, Standard_Transient)
+
+private:
+ Handle(StepKinematics_KinematicLinkRepresentationAssociation) myRepresentationRelation;
+ Handle(StepKinematics_ProductDefinitionRelationshipKinematics) myRepresentedProductRelation;
+
+};
+#endif // _StepKinematics_ContextDependentKinematicLinkRepresentation_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_CylindricalPair.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_CylindricalPair, StepKinematics_LowOrderKinematicPair)
+
+//=======================================================================
+//function : StepKinematics_CylindricalPair
+//purpose :
+//=======================================================================
+StepKinematics_CylindricalPair::StepKinematics_CylindricalPair ()
+{
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_CylindricalPair_HeaderFile_
+#define _StepKinematics_CylindricalPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_LowOrderKinematicPair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_CylindricalPair, StepKinematics_LowOrderKinematicPair)
+
+//! Representation of STEP entity CylindricalPair
+class StepKinematics_CylindricalPair : public StepKinematics_LowOrderKinematicPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_CylindricalPair();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_CylindricalPair, StepKinematics_LowOrderKinematicPair)
+
+};
+#endif // _StepKinematics_CylindricalPair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_CylindricalPairValue.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_CylindricalPairValue, StepKinematics_PairValue)
+
+//=======================================================================
+//function : StepKinematics_CylindricalPairValue
+//purpose :
+//=======================================================================
+StepKinematics_CylindricalPairValue::StepKinematics_CylindricalPairValue ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_CylindricalPairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Standard_Real theActualTranslation,
+ const Standard_Real theActualRotation)
+{
+ StepKinematics_PairValue::Init(theRepresentationItem_Name,
+ thePairValue_AppliesToPair);
+
+ myActualTranslation = theActualTranslation;
+
+ myActualRotation = theActualRotation;
+}
+
+//=======================================================================
+//function : ActualTranslation
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_CylindricalPairValue::ActualTranslation () const
+{
+ return myActualTranslation;
+}
+
+//=======================================================================
+//function : SetActualTranslation
+//purpose :
+//=======================================================================
+void StepKinematics_CylindricalPairValue::SetActualTranslation (const Standard_Real theActualTranslation)
+{
+ myActualTranslation = theActualTranslation;
+}
+
+//=======================================================================
+//function : ActualRotation
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_CylindricalPairValue::ActualRotation () const
+{
+ return myActualRotation;
+}
+
+//=======================================================================
+//function : SetActualRotation
+//purpose :
+//=======================================================================
+void StepKinematics_CylindricalPairValue::SetActualRotation (const Standard_Real theActualRotation)
+{
+ myActualRotation = theActualRotation;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_CylindricalPairValue_HeaderFile_
+#define _StepKinematics_CylindricalPairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_PairValue.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_CylindricalPairValue, StepKinematics_PairValue)
+
+//! Representation of STEP entity CylindricalPairValue
+class StepKinematics_CylindricalPairValue : public StepKinematics_PairValue
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_CylindricalPairValue();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Standard_Real theActualTranslation,
+ const Standard_Real theActualRotation);
+
+ //! Returns field ActualTranslation
+ Standard_EXPORT Standard_Real ActualTranslation() const;
+ //! Sets field ActualTranslation
+ Standard_EXPORT void SetActualTranslation (const Standard_Real theActualTranslation);
+
+ //! Returns field ActualRotation
+ Standard_EXPORT Standard_Real ActualRotation() const;
+ //! Sets field ActualRotation
+ Standard_EXPORT void SetActualRotation (const Standard_Real theActualRotation);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_CylindricalPairValue, StepKinematics_PairValue)
+
+private:
+ Standard_Real myActualTranslation;
+ Standard_Real myActualRotation;
+
+};
+#endif // _StepKinematics_CylindricalPairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_CylindricalPairWithRange.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_CylindricalPairWithRange, StepKinematics_CylindricalPair)
+
+//=======================================================================
+//function : StepKinematics_CylindricalPairWithRange
+//purpose :
+//=======================================================================
+StepKinematics_CylindricalPairWithRange::StepKinematics_CylindricalPairWithRange ()
+{
+ defLowerLimitActualTranslation = Standard_False;
+ defUpperLimitActualTranslation = Standard_False;
+ defLowerLimitActualRotation = Standard_False;
+ defUpperLimitActualRotation = Standard_False;
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_CylindricalPairWithRange::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Boolean theLowOrderKinematicPair_TX,
+ const Standard_Boolean theLowOrderKinematicPair_TY,
+ const Standard_Boolean theLowOrderKinematicPair_TZ,
+ const Standard_Boolean theLowOrderKinematicPair_RX,
+ const Standard_Boolean theLowOrderKinematicPair_RY,
+ const Standard_Boolean theLowOrderKinematicPair_RZ,
+ const Standard_Boolean hasLowerLimitActualTranslation,
+ const Standard_Real theLowerLimitActualTranslation,
+ const Standard_Boolean hasUpperLimitActualTranslation,
+ const Standard_Real theUpperLimitActualTranslation,
+ const Standard_Boolean hasLowerLimitActualRotation,
+ const Standard_Real theLowerLimitActualRotation,
+ const Standard_Boolean hasUpperLimitActualRotation,
+ const Standard_Real theUpperLimitActualRotation)
+{
+ StepKinematics_CylindricalPair::Init(theRepresentationItem_Name,
+ theItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2,
+ theKinematicPair_Joint,
+ theLowOrderKinematicPair_TX,
+ theLowOrderKinematicPair_TY,
+ theLowOrderKinematicPair_TZ,
+ theLowOrderKinematicPair_RX,
+ theLowOrderKinematicPair_RY,
+ theLowOrderKinematicPair_RZ);
+
+ defLowerLimitActualTranslation = hasLowerLimitActualTranslation;
+ if (defLowerLimitActualTranslation) {
+ myLowerLimitActualTranslation = theLowerLimitActualTranslation;
+ }
+ else myLowerLimitActualTranslation = 0;
+
+ defUpperLimitActualTranslation = hasUpperLimitActualTranslation;
+ if (defUpperLimitActualTranslation) {
+ myUpperLimitActualTranslation = theUpperLimitActualTranslation;
+ }
+ else myUpperLimitActualTranslation = 0;
+
+ defLowerLimitActualRotation = hasLowerLimitActualRotation;
+ if (defLowerLimitActualRotation) {
+ myLowerLimitActualRotation = theLowerLimitActualRotation;
+ }
+ else myLowerLimitActualRotation = 0;
+
+ defUpperLimitActualRotation = hasUpperLimitActualRotation;
+ if (defUpperLimitActualRotation) {
+ myUpperLimitActualRotation = theUpperLimitActualRotation;
+ }
+ else myUpperLimitActualRotation = 0;
+}
+
+//=======================================================================
+//function : LowerLimitActualTranslation
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_CylindricalPairWithRange::LowerLimitActualTranslation () const
+{
+ return myLowerLimitActualTranslation;
+}
+
+//=======================================================================
+//function : SetLowerLimitActualTranslation
+//purpose :
+//=======================================================================
+void StepKinematics_CylindricalPairWithRange::SetLowerLimitActualTranslation (const Standard_Real theLowerLimitActualTranslation)
+{
+ myLowerLimitActualTranslation = theLowerLimitActualTranslation;
+}
+
+//=======================================================================
+//function : HasLowerLimitActualTranslation
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_CylindricalPairWithRange::HasLowerLimitActualTranslation () const
+{
+ return defLowerLimitActualTranslation;
+}
+
+//=======================================================================
+//function : UpperLimitActualTranslation
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_CylindricalPairWithRange::UpperLimitActualTranslation () const
+{
+ return myUpperLimitActualTranslation;
+}
+
+//=======================================================================
+//function : SetUpperLimitActualTranslation
+//purpose :
+//=======================================================================
+void StepKinematics_CylindricalPairWithRange::SetUpperLimitActualTranslation (const Standard_Real theUpperLimitActualTranslation)
+{
+ myUpperLimitActualTranslation = theUpperLimitActualTranslation;
+}
+
+//=======================================================================
+//function : HasUpperLimitActualTranslation
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_CylindricalPairWithRange::HasUpperLimitActualTranslation () const
+{
+ return defUpperLimitActualTranslation;
+}
+
+//=======================================================================
+//function : LowerLimitActualRotation
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_CylindricalPairWithRange::LowerLimitActualRotation () const
+{
+ return myLowerLimitActualRotation;
+}
+
+//=======================================================================
+//function : SetLowerLimitActualRotation
+//purpose :
+//=======================================================================
+void StepKinematics_CylindricalPairWithRange::SetLowerLimitActualRotation (const Standard_Real theLowerLimitActualRotation)
+{
+ myLowerLimitActualRotation = theLowerLimitActualRotation;
+}
+
+//=======================================================================
+//function : HasLowerLimitActualRotation
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_CylindricalPairWithRange::HasLowerLimitActualRotation () const
+{
+ return defLowerLimitActualRotation;
+}
+
+//=======================================================================
+//function : UpperLimitActualRotation
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_CylindricalPairWithRange::UpperLimitActualRotation () const
+{
+ return myUpperLimitActualRotation;
+}
+
+//=======================================================================
+//function : SetUpperLimitActualRotation
+//purpose :
+//=======================================================================
+void StepKinematics_CylindricalPairWithRange::SetUpperLimitActualRotation (const Standard_Real theUpperLimitActualRotation)
+{
+ myUpperLimitActualRotation = theUpperLimitActualRotation;
+}
+
+//=======================================================================
+//function : HasUpperLimitActualRotation
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_CylindricalPairWithRange::HasUpperLimitActualRotation () const
+{
+ return defUpperLimitActualRotation;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_CylindricalPairWithRange_HeaderFile_
+#define _StepKinematics_CylindricalPairWithRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_CylindricalPair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_CylindricalPairWithRange, StepKinematics_CylindricalPair)
+
+//! Representation of STEP entity CylindricalPairWithRange
+class StepKinematics_CylindricalPairWithRange : public StepKinematics_CylindricalPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_CylindricalPairWithRange();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Boolean theLowOrderKinematicPair_TX,
+ const Standard_Boolean theLowOrderKinematicPair_TY,
+ const Standard_Boolean theLowOrderKinematicPair_TZ,
+ const Standard_Boolean theLowOrderKinematicPair_RX,
+ const Standard_Boolean theLowOrderKinematicPair_RY,
+ const Standard_Boolean theLowOrderKinematicPair_RZ,
+ const Standard_Boolean hasLowerLimitActualTranslation,
+ const Standard_Real theLowerLimitActualTranslation,
+ const Standard_Boolean hasUpperLimitActualTranslation,
+ const Standard_Real theUpperLimitActualTranslation,
+ const Standard_Boolean hasLowerLimitActualRotation,
+ const Standard_Real theLowerLimitActualRotation,
+ const Standard_Boolean hasUpperLimitActualRotation,
+ const Standard_Real theUpperLimitActualRotation);
+
+ //! Returns field LowerLimitActualTranslation
+ Standard_EXPORT Standard_Real LowerLimitActualTranslation() const;
+ //! Sets field LowerLimitActualTranslation
+ Standard_EXPORT void SetLowerLimitActualTranslation (const Standard_Real theLowerLimitActualTranslation);
+ //! Returns True if optional field LowerLimitActualTranslation is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitActualTranslation() const;
+
+ //! Returns field UpperLimitActualTranslation
+ Standard_EXPORT Standard_Real UpperLimitActualTranslation() const;
+ //! Sets field UpperLimitActualTranslation
+ Standard_EXPORT void SetUpperLimitActualTranslation (const Standard_Real theUpperLimitActualTranslation);
+ //! Returns True if optional field UpperLimitActualTranslation is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitActualTranslation() const;
+
+ //! Returns field LowerLimitActualRotation
+ Standard_EXPORT Standard_Real LowerLimitActualRotation() const;
+ //! Sets field LowerLimitActualRotation
+ Standard_EXPORT void SetLowerLimitActualRotation (const Standard_Real theLowerLimitActualRotation);
+ //! Returns True if optional field LowerLimitActualRotation is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitActualRotation() const;
+
+ //! Returns field UpperLimitActualRotation
+ Standard_EXPORT Standard_Real UpperLimitActualRotation() const;
+ //! Sets field UpperLimitActualRotation
+ Standard_EXPORT void SetUpperLimitActualRotation (const Standard_Real theUpperLimitActualRotation);
+ //! Returns True if optional field UpperLimitActualRotation is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitActualRotation() const;
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_CylindricalPairWithRange, StepKinematics_CylindricalPair)
+
+private:
+ Standard_Real myLowerLimitActualTranslation; //!< optional
+ Standard_Real myUpperLimitActualTranslation; //!< optional
+ Standard_Real myLowerLimitActualRotation; //!< optional
+ Standard_Real myUpperLimitActualRotation; //!< optional
+ Standard_Boolean defLowerLimitActualTranslation; //!< flag "is LowerLimitActualTranslation defined"
+ Standard_Boolean defUpperLimitActualTranslation; //!< flag "is UpperLimitActualTranslation defined"
+ Standard_Boolean defLowerLimitActualRotation; //!< flag "is LowerLimitActualRotation defined"
+ Standard_Boolean defUpperLimitActualRotation; //!< flag "is UpperLimitActualRotation defined"
+
+};
+#endif // _StepKinematics_CylindricalPairWithRange_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_FullyConstrainedPair.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_FullyConstrainedPair, StepKinematics_LowOrderKinematicPair)
+
+//=======================================================================
+//function : StepKinematics_FullyConstrainedPair
+//purpose :
+//=======================================================================
+StepKinematics_FullyConstrainedPair::StepKinematics_FullyConstrainedPair ()
+{
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_FullyConstrainedPair_HeaderFile_
+#define _StepKinematics_FullyConstrainedPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_LowOrderKinematicPair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_FullyConstrainedPair, StepKinematics_LowOrderKinematicPair)
+
+//! Representation of STEP entity FullyConstrainedPair
+class StepKinematics_FullyConstrainedPair : public StepKinematics_LowOrderKinematicPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_FullyConstrainedPair();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_FullyConstrainedPair, StepKinematics_LowOrderKinematicPair)
+
+};
+#endif // _StepKinematics_FullyConstrainedPair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_GearPair.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_GearPair, StepKinematics_LowOrderKinematicPairWithMotionCoupling)
+
+//=======================================================================
+//function : StepKinematics_GearPair
+//purpose :
+//=======================================================================
+StepKinematics_GearPair::StepKinematics_GearPair ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_GearPair::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Real theRadiusFirstLink,
+ const Standard_Real theRadiusSecondLink,
+ const Standard_Real theBevel,
+ const Standard_Real theHelicalAngle,
+ const Standard_Real theGearRatio)
+{
+ StepKinematics_LowOrderKinematicPairWithMotionCoupling::Init(theRepresentationItem_Name,
+ theItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2,
+ theKinematicPair_Joint);
+
+ myRadiusFirstLink = theRadiusFirstLink;
+
+ myRadiusSecondLink = theRadiusSecondLink;
+
+ myBevel = theBevel;
+
+ myHelicalAngle = theHelicalAngle;
+
+ myGearRatio = theGearRatio;
+}
+
+//=======================================================================
+//function : RadiusFirstLink
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_GearPair::RadiusFirstLink () const
+{
+ return myRadiusFirstLink;
+}
+
+//=======================================================================
+//function : SetRadiusFirstLink
+//purpose :
+//=======================================================================
+void StepKinematics_GearPair::SetRadiusFirstLink (const Standard_Real theRadiusFirstLink)
+{
+ myRadiusFirstLink = theRadiusFirstLink;
+}
+
+//=======================================================================
+//function : RadiusSecondLink
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_GearPair::RadiusSecondLink () const
+{
+ return myRadiusSecondLink;
+}
+
+//=======================================================================
+//function : SetRadiusSecondLink
+//purpose :
+//=======================================================================
+void StepKinematics_GearPair::SetRadiusSecondLink (const Standard_Real theRadiusSecondLink)
+{
+ myRadiusSecondLink = theRadiusSecondLink;
+}
+
+//=======================================================================
+//function : Bevel
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_GearPair::Bevel () const
+{
+ return myBevel;
+}
+
+//=======================================================================
+//function : SetBevel
+//purpose :
+//=======================================================================
+void StepKinematics_GearPair::SetBevel (const Standard_Real theBevel)
+{
+ myBevel = theBevel;
+}
+
+//=======================================================================
+//function : HelicalAngle
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_GearPair::HelicalAngle () const
+{
+ return myHelicalAngle;
+}
+
+//=======================================================================
+//function : SetHelicalAngle
+//purpose :
+//=======================================================================
+void StepKinematics_GearPair::SetHelicalAngle (const Standard_Real theHelicalAngle)
+{
+ myHelicalAngle = theHelicalAngle;
+}
+
+//=======================================================================
+//function : GearRatio
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_GearPair::GearRatio () const
+{
+ return myGearRatio;
+}
+
+//=======================================================================
+//function : SetGearRatio
+//purpose :
+//=======================================================================
+void StepKinematics_GearPair::SetGearRatio (const Standard_Real theGearRatio)
+{
+ myGearRatio = theGearRatio;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_GearPair_HeaderFile_
+#define _StepKinematics_GearPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_LowOrderKinematicPairWithMotionCoupling.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_GearPair, StepKinematics_LowOrderKinematicPairWithMotionCoupling)
+
+//! Representation of STEP entity GearPair
+class StepKinematics_GearPair : public StepKinematics_LowOrderKinematicPairWithMotionCoupling
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_GearPair();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Real theRadiusFirstLink,
+ const Standard_Real theRadiusSecondLink,
+ const Standard_Real theBevel,
+ const Standard_Real theHelicalAngle,
+ const Standard_Real theGearRatio);
+
+ //! Returns field RadiusFirstLink
+ Standard_EXPORT Standard_Real RadiusFirstLink() const;
+ //! Sets field RadiusFirstLink
+ Standard_EXPORT void SetRadiusFirstLink (const Standard_Real theRadiusFirstLink);
+
+ //! Returns field RadiusSecondLink
+ Standard_EXPORT Standard_Real RadiusSecondLink() const;
+ //! Sets field RadiusSecondLink
+ Standard_EXPORT void SetRadiusSecondLink (const Standard_Real theRadiusSecondLink);
+
+ //! Returns field Bevel
+ Standard_EXPORT Standard_Real Bevel() const;
+ //! Sets field Bevel
+ Standard_EXPORT void SetBevel (const Standard_Real theBevel);
+
+ //! Returns field HelicalAngle
+ Standard_EXPORT Standard_Real HelicalAngle() const;
+ //! Sets field HelicalAngle
+ Standard_EXPORT void SetHelicalAngle (const Standard_Real theHelicalAngle);
+
+ //! Returns field GearRatio
+ Standard_EXPORT Standard_Real GearRatio() const;
+ //! Sets field GearRatio
+ Standard_EXPORT void SetGearRatio (const Standard_Real theGearRatio);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_GearPair, StepKinematics_LowOrderKinematicPairWithMotionCoupling)
+
+private:
+ Standard_Real myRadiusFirstLink;
+ Standard_Real myRadiusSecondLink;
+ Standard_Real myBevel;
+ Standard_Real myHelicalAngle;
+ Standard_Real myGearRatio;
+
+};
+#endif // _StepKinematics_GearPair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_GearPairValue.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_GearPairValue, StepKinematics_PairValue)
+
+//=======================================================================
+//function : StepKinematics_GearPairValue
+//purpose :
+//=======================================================================
+StepKinematics_GearPairValue::StepKinematics_GearPairValue ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_GearPairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Standard_Real theActualRotation1)
+{
+ StepKinematics_PairValue::Init(theRepresentationItem_Name,
+ thePairValue_AppliesToPair);
+
+ myActualRotation1 = theActualRotation1;
+}
+
+//=======================================================================
+//function : ActualRotation1
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_GearPairValue::ActualRotation1 () const
+{
+ return myActualRotation1;
+}
+
+//=======================================================================
+//function : SetActualRotation1
+//purpose :
+//=======================================================================
+void StepKinematics_GearPairValue::SetActualRotation1 (const Standard_Real theActualRotation1)
+{
+ myActualRotation1 = theActualRotation1;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_GearPairValue_HeaderFile_
+#define _StepKinematics_GearPairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_PairValue.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_GearPairValue, StepKinematics_PairValue)
+
+//! Representation of STEP entity GearPairValue
+class StepKinematics_GearPairValue : public StepKinematics_PairValue
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_GearPairValue();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Standard_Real theActualRotation1);
+
+ //! Returns field ActualRotation1
+ Standard_EXPORT Standard_Real ActualRotation1() const;
+ //! Sets field ActualRotation1
+ Standard_EXPORT void SetActualRotation1 (const Standard_Real theActualRotation1);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_GearPairValue, StepKinematics_PairValue)
+
+private:
+ Standard_Real myActualRotation1;
+
+};
+#endif // _StepKinematics_GearPairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_GearPairWithRange.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_GearPairWithRange, StepKinematics_GearPair)
+
+//=======================================================================
+//function : StepKinematics_GearPairWithRange
+//purpose :
+//=======================================================================
+StepKinematics_GearPairWithRange::StepKinematics_GearPairWithRange ()
+{
+ defLowerLimitActualRotation1 = Standard_False;
+ defUpperLimitActualRotation1 = Standard_False;
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_GearPairWithRange::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Real theGearPair_RadiusFirstLink,
+ const Standard_Real theGearPair_RadiusSecondLink,
+ const Standard_Real theGearPair_Bevel,
+ const Standard_Real theGearPair_HelicalAngle,
+ const Standard_Real theGearPair_GearRatio,
+ const Standard_Boolean hasLowerLimitActualRotation1,
+ const Standard_Real theLowerLimitActualRotation1,
+ const Standard_Boolean hasUpperLimitActualRotation1,
+ const Standard_Real theUpperLimitActualRotation1)
+{
+ StepKinematics_GearPair::Init(theRepresentationItem_Name,
+ theItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2,
+ theKinematicPair_Joint,
+ theGearPair_RadiusFirstLink,
+ theGearPair_RadiusSecondLink,
+ theGearPair_Bevel,
+ theGearPair_HelicalAngle,
+ theGearPair_GearRatio);
+
+ defLowerLimitActualRotation1 = hasLowerLimitActualRotation1;
+ if (defLowerLimitActualRotation1) {
+ myLowerLimitActualRotation1 = theLowerLimitActualRotation1;
+ }
+ else myLowerLimitActualRotation1 = 0;
+
+ defUpperLimitActualRotation1 = hasUpperLimitActualRotation1;
+ if (defUpperLimitActualRotation1) {
+ myUpperLimitActualRotation1 = theUpperLimitActualRotation1;
+ }
+ else myUpperLimitActualRotation1 = 0;
+}
+
+//=======================================================================
+//function : LowerLimitActualRotation1
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_GearPairWithRange::LowerLimitActualRotation1 () const
+{
+ return myLowerLimitActualRotation1;
+}
+
+//=======================================================================
+//function : SetLowerLimitActualRotation1
+//purpose :
+//=======================================================================
+void StepKinematics_GearPairWithRange::SetLowerLimitActualRotation1 (const Standard_Real theLowerLimitActualRotation1)
+{
+ myLowerLimitActualRotation1 = theLowerLimitActualRotation1;
+}
+
+//=======================================================================
+//function : HasLowerLimitActualRotation1
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_GearPairWithRange::HasLowerLimitActualRotation1 () const
+{
+ return defLowerLimitActualRotation1;
+}
+
+//=======================================================================
+//function : UpperLimitActualRotation1
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_GearPairWithRange::UpperLimitActualRotation1 () const
+{
+ return myUpperLimitActualRotation1;
+}
+
+//=======================================================================
+//function : SetUpperLimitActualRotation1
+//purpose :
+//=======================================================================
+void StepKinematics_GearPairWithRange::SetUpperLimitActualRotation1 (const Standard_Real theUpperLimitActualRotation1)
+{
+ myUpperLimitActualRotation1 = theUpperLimitActualRotation1;
+}
+
+//=======================================================================
+//function : HasUpperLimitActualRotation1
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_GearPairWithRange::HasUpperLimitActualRotation1 () const
+{
+ return defUpperLimitActualRotation1;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_GearPairWithRange_HeaderFile_
+#define _StepKinematics_GearPairWithRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_GearPair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_GearPairWithRange, StepKinematics_GearPair)
+
+//! Representation of STEP entity GearPairWithRange
+class StepKinematics_GearPairWithRange : public StepKinematics_GearPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_GearPairWithRange();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Real theGearPair_RadiusFirstLink,
+ const Standard_Real theGearPair_RadiusSecondLink,
+ const Standard_Real theGearPair_Bevel,
+ const Standard_Real theGearPair_HelicalAngle,
+ const Standard_Real theGearPair_GearRatio,
+ const Standard_Boolean hasLowerLimitActualRotation1,
+ const Standard_Real theLowerLimitActualRotation1,
+ const Standard_Boolean hasUpperLimitActualRotation1,
+ const Standard_Real theUpperLimitActualRotation1);
+
+ //! Returns field LowerLimitActualRotation1
+ Standard_EXPORT Standard_Real LowerLimitActualRotation1() const;
+ //! Sets field LowerLimitActualRotation1
+ Standard_EXPORT void SetLowerLimitActualRotation1 (const Standard_Real theLowerLimitActualRotation1);
+ //! Returns True if optional field LowerLimitActualRotation1 is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitActualRotation1() const;
+
+ //! Returns field UpperLimitActualRotation1
+ Standard_EXPORT Standard_Real UpperLimitActualRotation1() const;
+ //! Sets field UpperLimitActualRotation1
+ Standard_EXPORT void SetUpperLimitActualRotation1 (const Standard_Real theUpperLimitActualRotation1);
+ //! Returns True if optional field UpperLimitActualRotation1 is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitActualRotation1() const;
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_GearPairWithRange, StepKinematics_GearPair)
+
+private:
+ Standard_Real myLowerLimitActualRotation1; //!< optional
+ Standard_Real myUpperLimitActualRotation1; //!< optional
+ Standard_Boolean defLowerLimitActualRotation1; //!< flag "is LowerLimitActualRotation1 defined"
+ Standard_Boolean defUpperLimitActualRotation1; //!< flag "is UpperLimitActualRotation1 defined"
+
+};
+#endif // _StepKinematics_GearPairWithRange_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_HighOrderKinematicPair.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_HighOrderKinematicPair, StepKinematics_KinematicPair)
+
+//=======================================================================
+//function : StepKinematics_HighOrderKinematicPair
+//purpose :
+//=======================================================================
+StepKinematics_HighOrderKinematicPair::StepKinematics_HighOrderKinematicPair ()
+{
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_HighOrderKinematicPair_HeaderFile_
+#define _StepKinematics_HighOrderKinematicPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_HighOrderKinematicPair, StepKinematics_KinematicPair)
+
+//! Representation of STEP entity HighOrderKinematicPair
+class StepKinematics_HighOrderKinematicPair : public StepKinematics_KinematicPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_HighOrderKinematicPair();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_HighOrderKinematicPair, StepKinematics_KinematicPair)
+
+};
+#endif // _StepKinematics_HighOrderKinematicPair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_HomokineticPair.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_HomokineticPair, StepKinematics_UniversalPair)
+
+//=======================================================================
+//function : StepKinematics_HomokineticPair
+//purpose :
+//=======================================================================
+StepKinematics_HomokineticPair::StepKinematics_HomokineticPair ()
+{
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_HomokineticPair_HeaderFile_
+#define _StepKinematics_HomokineticPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_UniversalPair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_HomokineticPair, StepKinematics_UniversalPair)
+
+//! Representation of STEP entity HomokineticPair
+class StepKinematics_HomokineticPair : public StepKinematics_UniversalPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_HomokineticPair();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_HomokineticPair, StepKinematics_UniversalPair)
+
+};
+#endif // _StepKinematics_HomokineticPair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_KinematicJoint.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_KinematicJoint, StepShape_Edge)
+
+//=======================================================================
+//function : StepKinematics_KinematicJoint
+//purpose :
+//=======================================================================
+StepKinematics_KinematicJoint::StepKinematics_KinematicJoint ()
+{
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_KinematicJoint_HeaderFile_
+#define _StepKinematics_KinematicJoint_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepShape_Edge.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepShape_Vertex.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_KinematicJoint, StepShape_Edge)
+
+//! Representation of STEP entity KinematicJoint
+class StepKinematics_KinematicJoint : public StepShape_Edge
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_KinematicJoint();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_KinematicJoint, StepShape_Edge)
+
+};
+#endif // _StepKinematics_KinematicJoint_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_KinematicLink.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_KinematicLink, StepShape_Vertex)
+
+//=======================================================================
+//function : StepKinematics_KinematicLink
+//purpose :
+//=======================================================================
+StepKinematics_KinematicLink::StepKinematics_KinematicLink ()
+{
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_KinematicLink_HeaderFile_
+#define _StepKinematics_KinematicLink_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepShape_Vertex.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_KinematicLink, StepShape_Vertex)
+
+//! Representation of STEP entity KinematicLink
+class StepKinematics_KinematicLink : public StepShape_Vertex
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_KinematicLink();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_KinematicLink, StepShape_Vertex)
+
+};
+#endif // _StepKinematics_KinematicLink_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_KinematicLinkRepresentation.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_KinematicLinkRepresentation, StepRepr_Representation)
+
+//=======================================================================
+//function : StepKinematics_KinematicLinkRepresentation
+//purpose :
+//=======================================================================
+StepKinematics_KinematicLinkRepresentation::StepKinematics_KinematicLinkRepresentation ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_KinematicLinkRepresentation::Init (const Handle(TCollection_HAsciiString)& theRepresentation_Name,
+ const Handle(StepRepr_HArray1OfRepresentationItem)& theRepresentation_Items,
+ const Handle(StepRepr_RepresentationContext)& theRepresentation_ContextOfItems,
+ const Handle(StepKinematics_KinematicLink)& theRepresentedLink)
+{
+ StepRepr_Representation::Init(theRepresentation_Name,
+ theRepresentation_Items,
+ theRepresentation_ContextOfItems);
+
+ myRepresentedLink = theRepresentedLink;
+}
+
+//=======================================================================
+//function : RepresentedLink
+//purpose :
+//=======================================================================
+Handle(StepKinematics_KinematicLink) StepKinematics_KinematicLinkRepresentation::RepresentedLink () const
+{
+ return myRepresentedLink;
+}
+
+//=======================================================================
+//function : SetRepresentedLink
+//purpose :
+//=======================================================================
+void StepKinematics_KinematicLinkRepresentation::SetRepresentedLink (const Handle(StepKinematics_KinematicLink)& theRepresentedLink)
+{
+ myRepresentedLink = theRepresentedLink;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_KinematicLinkRepresentation_HeaderFile_
+#define _StepKinematics_KinematicLinkRepresentation_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepRepr_Representation.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_RepresentationContext.hxx>
+#include <StepKinematics_KinematicLink.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_KinematicLinkRepresentation, StepRepr_Representation)
+
+//! Representation of STEP entity KinematicLinkRepresentation
+class StepKinematics_KinematicLinkRepresentation : public StepRepr_Representation
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_KinematicLinkRepresentation();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentation_Name,
+ const Handle(StepRepr_HArray1OfRepresentationItem)& theRepresentation_Items,
+ const Handle(StepRepr_RepresentationContext)& theRepresentation_ContextOfItems,
+ const Handle(StepKinematics_KinematicLink)& theRepresentedLink);
+
+ //! Returns field RepresentedLink
+ Standard_EXPORT Handle(StepKinematics_KinematicLink) RepresentedLink() const;
+ //! Sets field RepresentedLink
+ Standard_EXPORT void SetRepresentedLink (const Handle(StepKinematics_KinematicLink)& theRepresentedLink);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_KinematicLinkRepresentation, StepRepr_Representation)
+
+private:
+ Handle(StepKinematics_KinematicLink) myRepresentedLink;
+
+};
+#endif // _StepKinematics_KinematicLinkRepresentation_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_KinematicLinkRepresentationAssociation.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_KinematicLinkRepresentationAssociation, StepRepr_RepresentationRelationship)
+
+//=======================================================================
+//function : StepKinematics_KinematicLinkRepresentationAssociation
+//purpose :
+//=======================================================================
+StepKinematics_KinematicLinkRepresentationAssociation::StepKinematics_KinematicLinkRepresentationAssociation ()
+{
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_KinematicLinkRepresentationAssociation_HeaderFile_
+#define _StepKinematics_KinematicLinkRepresentationAssociation_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepRepr_RepresentationRelationship.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationOrRepresentationReference.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_KinematicLinkRepresentationAssociation, StepRepr_RepresentationRelationship)
+
+//! Representation of STEP entity KinematicLinkRepresentationAssociation
+class StepKinematics_KinematicLinkRepresentationAssociation : public StepRepr_RepresentationRelationship
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_KinematicLinkRepresentationAssociation();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_KinematicLinkRepresentationAssociation, StepRepr_RepresentationRelationship)
+
+};
+#endif // _StepKinematics_KinematicLinkRepresentationAssociation_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_KinematicPair.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_KinematicPair, StepGeom_GeometricRepresentationItem)
+
+//=======================================================================
+//function : StepKinematics_KinematicPair
+//purpose :
+//=======================================================================
+StepKinematics_KinematicPair::StepKinematics_KinematicPair ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_KinematicPair::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean /*hasItemDefinedTransformation_Description*/,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theJoint)
+{
+ StepGeom_GeometricRepresentationItem::Init(theRepresentationItem_Name);
+ myItemDefinedTransformation = new StepRepr_ItemDefinedTransformation;
+ myItemDefinedTransformation->Init(theItemDefinedTransformation_Name,
+ /*hasItemDefinedTransformation_Description,*/
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2);
+
+ myJoint = theJoint;
+}
+
+//=======================================================================
+//function : ItemDefinedTransformation
+//purpose :
+//=======================================================================
+Handle(StepRepr_ItemDefinedTransformation) StepKinematics_KinematicPair::ItemDefinedTransformation () const
+{
+ return myItemDefinedTransformation;
+}
+
+//=======================================================================
+//function : SetItemDefinedTransformation
+//purpose :
+//=======================================================================
+void StepKinematics_KinematicPair::SetItemDefinedTransformation (const Handle(StepRepr_ItemDefinedTransformation)& theItemDefinedTransformation)
+{
+ myItemDefinedTransformation = theItemDefinedTransformation;
+}
+
+//=======================================================================
+//function : Joint
+//purpose :
+//=======================================================================
+Handle(StepKinematics_KinematicJoint) StepKinematics_KinematicPair::Joint () const
+{
+ return myJoint;
+}
+
+//=======================================================================
+//function : SetJoint
+//purpose :
+//=======================================================================
+void StepKinematics_KinematicPair::SetJoint (const Handle(StepKinematics_KinematicJoint)& theJoint)
+{
+ myJoint = theJoint;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_KinematicPair_HeaderFile_
+#define _StepKinematics_KinematicPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepGeom_GeometricRepresentationItem.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_KinematicPair, StepGeom_GeometricRepresentationItem)
+
+//! Representation of STEP entity KinematicPair
+class StepKinematics_KinematicPair : public StepGeom_GeometricRepresentationItem
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_KinematicPair();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theJoint);
+
+ //! Returns data for supertype ItemDefinedTransformation
+ Standard_EXPORT Handle(StepRepr_ItemDefinedTransformation) ItemDefinedTransformation() const;
+ //! Sets data for supertype ItemDefinedTransformation
+ Standard_EXPORT void SetItemDefinedTransformation (const Handle(StepRepr_ItemDefinedTransformation)& theItemDefinedTransformation);
+
+ //! Returns field Joint
+ Standard_EXPORT Handle(StepKinematics_KinematicJoint) Joint() const;
+ //! Sets field Joint
+ Standard_EXPORT void SetJoint (const Handle(StepKinematics_KinematicJoint)& theJoint);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_KinematicPair, StepGeom_GeometricRepresentationItem)
+
+private:
+ Handle(StepRepr_ItemDefinedTransformation) myItemDefinedTransformation; //!< supertype
+ Handle(StepKinematics_KinematicJoint) myJoint;
+
+};
+#endif // _StepKinematics_KinematicPair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_KinematicPropertyDefinitionRepresentation.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_KinematicPropertyDefinitionRepresentation, StepRepr_PropertyDefinitionRepresentation)
+
+//=======================================================================
+//function : StepKinematics_KinematicPropertyDefinitionRepresentation
+//purpose :
+//=======================================================================
+StepKinematics_KinematicPropertyDefinitionRepresentation::StepKinematics_KinematicPropertyDefinitionRepresentation ()
+{
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_KinematicPropertyDefinitionRepresentation_HeaderFile_
+#define _StepKinematics_KinematicPropertyDefinitionRepresentation_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepRepr_PropertyDefinitionRepresentation.hxx>
+
+#include <StepRepr_RepresentedDefinition.hxx>
+#include <StepRepr_Representation.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_KinematicPropertyDefinitionRepresentation, StepRepr_PropertyDefinitionRepresentation)
+
+//! Representation of STEP entity KinematicPropertyDefinitionRepresentation
+class StepKinematics_KinematicPropertyDefinitionRepresentation : public StepRepr_PropertyDefinitionRepresentation
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_KinematicPropertyDefinitionRepresentation();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_KinematicPropertyDefinitionRepresentation, StepRepr_PropertyDefinitionRepresentation)
+
+};
+#endif // _StepKinematics_KinematicPropertyDefinitionRepresentation_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_KinematicPropertyMechanismRepresentation.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_KinematicPropertyMechanismRepresentation, StepKinematics_KinematicPropertyDefinitionRepresentation)
+
+//=======================================================================
+//function : StepKinematics_KinematicPropertyMechanismRepresentation
+//purpose :
+//=======================================================================
+StepKinematics_KinematicPropertyMechanismRepresentation::StepKinematics_KinematicPropertyMechanismRepresentation ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_KinematicPropertyMechanismRepresentation::Init (const StepRepr_RepresentedDefinition& thePropertyDefinitionRepresentation_Definition,
+ const Handle(StepRepr_Representation)& thePropertyDefinitionRepresentation_UsedRepresentation,
+ const Handle(StepKinematics_KinematicLinkRepresentation)& theBase)
+{
+ StepKinematics_KinematicPropertyDefinitionRepresentation::Init(thePropertyDefinitionRepresentation_Definition,
+ thePropertyDefinitionRepresentation_UsedRepresentation);
+
+ myBase = theBase;
+}
+
+//=======================================================================
+//function : Base
+//purpose :
+//=======================================================================
+Handle(StepKinematics_KinematicLinkRepresentation) StepKinematics_KinematicPropertyMechanismRepresentation::Base () const
+{
+ return myBase;
+}
+
+//=======================================================================
+//function : SetBase
+//purpose :
+//=======================================================================
+void StepKinematics_KinematicPropertyMechanismRepresentation::SetBase (const Handle(StepKinematics_KinematicLinkRepresentation)& theBase)
+{
+ myBase = theBase;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_KinematicPropertyMechanismRepresentation_HeaderFile_
+#define _StepKinematics_KinematicPropertyMechanismRepresentation_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_KinematicPropertyDefinitionRepresentation.hxx>
+
+#include <StepRepr_RepresentedDefinition.hxx>
+#include <StepRepr_Representation.hxx>
+#include <StepKinematics_KinematicLinkRepresentation.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_KinematicPropertyMechanismRepresentation, StepKinematics_KinematicPropertyDefinitionRepresentation)
+
+//! Representation of STEP entity KinematicPropertyMechanismRepresentation
+class StepKinematics_KinematicPropertyMechanismRepresentation : public StepKinematics_KinematicPropertyDefinitionRepresentation
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_KinematicPropertyMechanismRepresentation();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const StepRepr_RepresentedDefinition& thePropertyDefinitionRepresentation_Definition,
+ const Handle(StepRepr_Representation)& thePropertyDefinitionRepresentation_UsedRepresentation,
+ const Handle(StepKinematics_KinematicLinkRepresentation)& theBase);
+
+ //! Returns field Base
+ Standard_EXPORT Handle(StepKinematics_KinematicLinkRepresentation) Base() const;
+ //! Sets field Base
+ Standard_EXPORT void SetBase (const Handle(StepKinematics_KinematicLinkRepresentation)& theBase);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_KinematicPropertyMechanismRepresentation, StepKinematics_KinematicPropertyDefinitionRepresentation)
+
+private:
+ Handle(StepKinematics_KinematicLinkRepresentation) myBase;
+
+};
+#endif // _StepKinematics_KinematicPropertyMechanismRepresentation_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_KinematicTopologyDirectedStructure.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_KinematicTopologyDirectedStructure, StepRepr_Representation)
+
+//=======================================================================
+//function : StepKinematics_KinematicTopologyDirectedStructure
+//purpose :
+//=======================================================================
+StepKinematics_KinematicTopologyDirectedStructure::StepKinematics_KinematicTopologyDirectedStructure ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_KinematicTopologyDirectedStructure::Init (const Handle(TCollection_HAsciiString)& theRepresentation_Name,
+ const Handle(StepRepr_HArray1OfRepresentationItem)& theRepresentation_Items,
+ const Handle(StepRepr_RepresentationContext)& theRepresentation_ContextOfItems,
+ const Handle(StepKinematics_KinematicTopologyStructure)& theParent)
+{
+ StepRepr_Representation::Init(theRepresentation_Name,
+ theRepresentation_Items,
+ theRepresentation_ContextOfItems);
+
+ myParent = theParent;
+}
+
+//=======================================================================
+//function : Parent
+//purpose :
+//=======================================================================
+Handle(StepKinematics_KinematicTopologyStructure) StepKinematics_KinematicTopologyDirectedStructure::Parent () const
+{
+ return myParent;
+}
+
+//=======================================================================
+//function : SetParent
+//purpose :
+//=======================================================================
+void StepKinematics_KinematicTopologyDirectedStructure::SetParent (const Handle(StepKinematics_KinematicTopologyStructure)& theParent)
+{
+ myParent = theParent;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_KinematicTopologyDirectedStructure_HeaderFile_
+#define _StepKinematics_KinematicTopologyDirectedStructure_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepRepr_Representation.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_RepresentationContext.hxx>
+#include <StepKinematics_KinematicTopologyStructure.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_KinematicTopologyDirectedStructure, StepRepr_Representation)
+
+//! Representation of STEP entity KinematicTopologyDirectedStructure
+class StepKinematics_KinematicTopologyDirectedStructure : public StepRepr_Representation
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_KinematicTopologyDirectedStructure();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentation_Name,
+ const Handle(StepRepr_HArray1OfRepresentationItem)& theRepresentation_Items,
+ const Handle(StepRepr_RepresentationContext)& theRepresentation_ContextOfItems,
+ const Handle(StepKinematics_KinematicTopologyStructure)& theParent);
+
+ //! Returns field Parent
+ Standard_EXPORT Handle(StepKinematics_KinematicTopologyStructure) Parent() const;
+ //! Sets field Parent
+ Standard_EXPORT void SetParent (const Handle(StepKinematics_KinematicTopologyStructure)& theParent);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_KinematicTopologyDirectedStructure, StepRepr_Representation)
+
+private:
+ Handle(StepKinematics_KinematicTopologyStructure) myParent;
+
+};
+#endif // _StepKinematics_KinematicTopologyDirectedStructure_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_KinematicTopologyNetworkStructure.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_KinematicTopologyNetworkStructure, StepRepr_Representation)
+
+//=======================================================================
+//function : StepKinematics_KinematicTopologyNetworkStructure
+//purpose :
+//=======================================================================
+StepKinematics_KinematicTopologyNetworkStructure::StepKinematics_KinematicTopologyNetworkStructure ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_KinematicTopologyNetworkStructure::Init (const Handle(TCollection_HAsciiString)& theRepresentation_Name,
+ const Handle(StepRepr_HArray1OfRepresentationItem)& theRepresentation_Items,
+ const Handle(StepRepr_RepresentationContext)& theRepresentation_ContextOfItems,
+ const Handle(StepKinematics_KinematicTopologyStructure)& theParent)
+{
+ StepRepr_Representation::Init(theRepresentation_Name,
+ theRepresentation_Items,
+ theRepresentation_ContextOfItems);
+
+ myParent = theParent;
+}
+
+//=======================================================================
+//function : Parent
+//purpose :
+//=======================================================================
+Handle(StepKinematics_KinematicTopologyStructure) StepKinematics_KinematicTopologyNetworkStructure::Parent () const
+{
+ return myParent;
+}
+
+//=======================================================================
+//function : SetParent
+//purpose :
+//=======================================================================
+void StepKinematics_KinematicTopologyNetworkStructure::SetParent (const Handle(StepKinematics_KinematicTopologyStructure)& theParent)
+{
+ myParent = theParent;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_KinematicTopologyNetworkStructure_HeaderFile_
+#define _StepKinematics_KinematicTopologyNetworkStructure_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepRepr_Representation.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_RepresentationContext.hxx>
+#include <StepKinematics_KinematicTopologyStructure.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_KinematicTopologyNetworkStructure, StepRepr_Representation)
+
+//! Representation of STEP entity KinematicTopologyNetworkStructure
+class StepKinematics_KinematicTopologyNetworkStructure : public StepRepr_Representation
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_KinematicTopologyNetworkStructure();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentation_Name,
+ const Handle(StepRepr_HArray1OfRepresentationItem)& theRepresentation_Items,
+ const Handle(StepRepr_RepresentationContext)& theRepresentation_ContextOfItems,
+ const Handle(StepKinematics_KinematicTopologyStructure)& theParent);
+
+ //! Returns field Parent
+ Standard_EXPORT Handle(StepKinematics_KinematicTopologyStructure) Parent() const;
+ //! Sets field Parent
+ Standard_EXPORT void SetParent (const Handle(StepKinematics_KinematicTopologyStructure)& theParent);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_KinematicTopologyNetworkStructure, StepRepr_Representation)
+
+private:
+ Handle(StepKinematics_KinematicTopologyStructure) myParent;
+
+};
+#endif // _StepKinematics_KinematicTopologyNetworkStructure_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_KinematicTopologyRepresentationSelect.hxx>
+
+#include <StepKinematics_KinematicTopologyDirectedStructure.hxx>
+#include <StepKinematics_KinematicTopologyNetworkStructure.hxx>
+#include <StepKinematics_KinematicTopologyStructure.hxx>
+
+//=======================================================================
+//function : StepKinematics_KinematicTopologyRepresentationSelect
+//purpose :
+//=======================================================================
+StepKinematics_KinematicTopologyRepresentationSelect::StepKinematics_KinematicTopologyRepresentationSelect ()
+{
+}
+
+//=======================================================================
+//function : CaseNum
+//purpose :
+//=======================================================================
+Standard_Integer StepKinematics_KinematicTopologyRepresentationSelect::CaseNum (const Handle(Standard_Transient)& ent) const
+{
+ if (ent.IsNull()) return 0;
+ if (ent->IsKind(STANDARD_TYPE(StepKinematics_KinematicTopologyDirectedStructure))) return 1;
+ if (ent->IsKind(STANDARD_TYPE(StepKinematics_KinematicTopologyNetworkStructure))) return 2;
+ if (ent->IsKind(STANDARD_TYPE(StepKinematics_KinematicTopologyStructure))) return 3;
+ return 0;
+}
+
+//=======================================================================
+//function : KinematicTopologyDirectedStructure
+//purpose :
+//=======================================================================
+Handle(StepKinematics_KinematicTopologyDirectedStructure) StepKinematics_KinematicTopologyRepresentationSelect::KinematicTopologyDirectedStructure () const
+{
+ return Handle(StepKinematics_KinematicTopologyDirectedStructure)::DownCast(Value());
+}
+
+//=======================================================================
+//function : KinematicTopologyNetworkStructure
+//purpose :
+//=======================================================================
+Handle(StepKinematics_KinematicTopologyNetworkStructure) StepKinematics_KinematicTopologyRepresentationSelect::KinematicTopologyNetworkStructure () const
+{
+ return Handle(StepKinematics_KinematicTopologyNetworkStructure)::DownCast(Value());
+}
+
+//=======================================================================
+//function : KinematicTopologyStructure
+//purpose :
+//=======================================================================
+Handle(StepKinematics_KinematicTopologyStructure) StepKinematics_KinematicTopologyRepresentationSelect::KinematicTopologyStructure () const
+{
+ return Handle(StepKinematics_KinematicTopologyStructure)::DownCast(Value());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_KinematicTopologyRepresentationSelect_HeaderFile
+#define _StepKinematics_KinematicTopologyRepresentationSelect_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+#include <StepData_SelectType.hxx>
+#include <Standard_Integer.hxx>
+
+class Standard_Transient;
+class StepKinematics_KinematicTopologyDirectedStructure;
+class StepKinematics_KinematicTopologyNetworkStructure;
+class StepKinematics_KinematicTopologyStructure;
+
+//! Representation of STEP SELECT type KinematicTopologyRepresentationSelect
+class StepKinematics_KinematicTopologyRepresentationSelect : public StepData_SelectType
+{
+
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ //! Empty constructor
+ Standard_EXPORT StepKinematics_KinematicTopologyRepresentationSelect();
+
+ //! Recognizes a kind of KinematicTopologyRepresentationSelect select type
+ //! -- 1 -> KinematicTopologyDirectedStructure
+ //! -- 2 -> KinematicTopologyNetworkStructure
+ //! -- 3 -> KinematicTopologyStructure
+ Standard_EXPORT Standard_Integer CaseNum (const Handle(Standard_Transient)& ent) const Standard_OVERRIDE;
+
+ //! Returns Value as KinematicTopologyDirectedStructure (or Null if another type)
+ Standard_EXPORT Handle(StepKinematics_KinematicTopologyDirectedStructure) KinematicTopologyDirectedStructure() const;
+
+ //! Returns Value as KinematicTopologyNetworkStructure (or Null if another type)
+ Standard_EXPORT Handle(StepKinematics_KinematicTopologyNetworkStructure) KinematicTopologyNetworkStructure() const;
+
+ //! Returns Value as KinematicTopologyStructure (or Null if another type)
+ Standard_EXPORT Handle(StepKinematics_KinematicTopologyStructure) KinematicTopologyStructure() const;
+
+};
+#endif // _StepKinematics_KinematicTopologyRepresentationSelect_HeaderFile
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_KinematicTopologyStructure.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_KinematicTopologyStructure, StepRepr_Representation)
+
+//=======================================================================
+//function : StepKinematics_KinematicTopologyStructure
+//purpose :
+//=======================================================================
+StepKinematics_KinematicTopologyStructure::StepKinematics_KinematicTopologyStructure ()
+{
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_KinematicTopologyStructure_HeaderFile_
+#define _StepKinematics_KinematicTopologyStructure_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepRepr_Representation.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_RepresentationContext.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_KinematicTopologyStructure, StepRepr_Representation)
+
+//! Representation of STEP entity KinematicTopologyStructure
+class StepKinematics_KinematicTopologyStructure : public StepRepr_Representation
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_KinematicTopologyStructure();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_KinematicTopologyStructure, StepRepr_Representation)
+
+};
+#endif // _StepKinematics_KinematicTopologyStructure_HeaderFile_
--- /dev/null
+// Created on : Fri May 08 19:02:07 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_LinearFlexibleAndPinionPair.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_LinearFlexibleAndPinionPair, StepKinematics_LowOrderKinematicPairWithMotionCoupling)
+
+//=======================================================================
+//function : StepKinematics_LinearFlexibleAndPinionPair
+//purpose :
+//=======================================================================
+StepKinematics_LinearFlexibleAndPinionPair::StepKinematics_LinearFlexibleAndPinionPair ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_LinearFlexibleAndPinionPair::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Real thePinionRadius)
+{
+ StepKinematics_LowOrderKinematicPairWithMotionCoupling::Init(theRepresentationItem_Name,
+ theItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2,
+ theKinematicPair_Joint);
+
+ myPinionRadius = thePinionRadius;
+}
+
+//=======================================================================
+//function : PinionRadius
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_LinearFlexibleAndPinionPair::PinionRadius () const
+{
+ return myPinionRadius;
+}
+
+//=======================================================================
+//function : SetPinionRadius
+//purpose :
+//=======================================================================
+void StepKinematics_LinearFlexibleAndPinionPair::SetPinionRadius (const Standard_Real thePinionRadius)
+{
+ myPinionRadius = thePinionRadius;
+}
--- /dev/null
+// Created on : Fri May 08 19:02:07 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_LinearFlexibleAndPinionPair_HeaderFile_
+#define _StepKinematics_LinearFlexibleAndPinionPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_LowOrderKinematicPairWithMotionCoupling.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_LinearFlexibleAndPinionPair, StepKinematics_LowOrderKinematicPairWithMotionCoupling)
+
+//! Representation of STEP entity LinearFlexibleAndPinionPair
+class StepKinematics_LinearFlexibleAndPinionPair : public StepKinematics_LowOrderKinematicPairWithMotionCoupling
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_LinearFlexibleAndPinionPair();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Real thePinionRadius);
+
+ //! Returns field PinionRadius
+ Standard_EXPORT Standard_Real PinionRadius() const;
+ //! Sets field PinionRadius
+ Standard_EXPORT void SetPinionRadius (const Standard_Real thePinionRadius);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_LinearFlexibleAndPinionPair, StepKinematics_LowOrderKinematicPairWithMotionCoupling)
+
+private:
+ Standard_Real myPinionRadius;
+
+};
+#endif // _StepKinematics_LinearFlexibleAndPinionPair_HeaderFile_
--- /dev/null
+// Created on : Fri May 08 19:02:07 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_LinearFlexibleAndPlanarCurvePair.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_LinearFlexibleAndPlanarCurvePair, StepKinematics_HighOrderKinematicPair)
+
+//=======================================================================
+//function : StepKinematics_LinearFlexibleAndPlanarCurvePair
+//purpose :
+//=======================================================================
+StepKinematics_LinearFlexibleAndPlanarCurvePair::StepKinematics_LinearFlexibleAndPlanarCurvePair ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_LinearFlexibleAndPlanarCurvePair::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Handle(StepGeom_Curve)& thePairCurve,
+ const Standard_Boolean theOrientation)
+{
+ StepKinematics_HighOrderKinematicPair::Init(theRepresentationItem_Name,
+ theItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2,
+ theKinematicPair_Joint);
+
+ myPairCurve = thePairCurve;
+
+ myOrientation = theOrientation;
+}
+
+//=======================================================================
+//function : PairCurve
+//purpose :
+//=======================================================================
+Handle(StepGeom_Curve) StepKinematics_LinearFlexibleAndPlanarCurvePair::PairCurve () const
+{
+ return myPairCurve;
+}
+
+//=======================================================================
+//function : SetPairCurve
+//purpose :
+//=======================================================================
+void StepKinematics_LinearFlexibleAndPlanarCurvePair::SetPairCurve (const Handle(StepGeom_Curve)& thePairCurve)
+{
+ myPairCurve = thePairCurve;
+}
+
+//=======================================================================
+//function : Orientation
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_LinearFlexibleAndPlanarCurvePair::Orientation () const
+{
+ return myOrientation;
+}
+
+//=======================================================================
+//function : SetOrientation
+//purpose :
+//=======================================================================
+void StepKinematics_LinearFlexibleAndPlanarCurvePair::SetOrientation (const Standard_Boolean theOrientation)
+{
+ myOrientation = theOrientation;
+}
--- /dev/null
+// Created on : Fri May 08 19:02:07 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_LinearFlexibleAndPlanarCurvePair_HeaderFile_
+#define _StepKinematics_LinearFlexibleAndPlanarCurvePair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_HighOrderKinematicPair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Curve.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_LinearFlexibleAndPlanarCurvePair, StepKinematics_HighOrderKinematicPair)
+
+//! Representation of STEP entity LinearFlexibleAndPlanarCurvePair
+class StepKinematics_LinearFlexibleAndPlanarCurvePair : public StepKinematics_HighOrderKinematicPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_LinearFlexibleAndPlanarCurvePair();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Handle(StepGeom_Curve)& thePairCurve,
+ const Standard_Boolean theOrientation);
+
+ //! Returns field PairCurve
+ Standard_EXPORT Handle(StepGeom_Curve) PairCurve() const;
+ //! Sets field PairCurve
+ Standard_EXPORT void SetPairCurve (const Handle(StepGeom_Curve)& thePairCurve);
+
+ //! Returns field Orientation
+ Standard_EXPORT Standard_Boolean Orientation() const;
+ //! Sets field Orientation
+ Standard_EXPORT void SetOrientation (const Standard_Boolean theOrientation);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_LinearFlexibleAndPlanarCurvePair, StepKinematics_HighOrderKinematicPair)
+
+private:
+ Handle(StepGeom_Curve) myPairCurve;
+ Standard_Boolean myOrientation;
+
+};
+#endif // _StepKinematics_LinearFlexibleAndPlanarCurvePair_HeaderFile_
--- /dev/null
+// Created on : Fri May 08 19:02:07 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_LinearFlexibleLinkRepresentation.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_LinearFlexibleLinkRepresentation, StepKinematics_KinematicLinkRepresentation)
+
+//=======================================================================
+//function : StepKinematics_LinearFlexibleLinkRepresentation
+//purpose :
+//=======================================================================
+StepKinematics_LinearFlexibleLinkRepresentation::StepKinematics_LinearFlexibleLinkRepresentation ()
+{
+}
--- /dev/null
+// Created on : Fri May 08 19:02:07 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_LinearFlexibleLinkRepresentation_HeaderFile_
+#define _StepKinematics_LinearFlexibleLinkRepresentation_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_KinematicLinkRepresentation.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_RepresentationContext.hxx>
+#include <StepKinematics_KinematicLink.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_LinearFlexibleLinkRepresentation, StepKinematics_KinematicLinkRepresentation)
+
+//! Representation of STEP entity LinearFlexibleLinkRepresentation
+class StepKinematics_LinearFlexibleLinkRepresentation : public StepKinematics_KinematicLinkRepresentation
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_LinearFlexibleLinkRepresentation();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_LinearFlexibleLinkRepresentation, StepKinematics_KinematicLinkRepresentation)
+
+};
+#endif // _StepKinematics_LinearFlexibleLinkRepresentation_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_LowOrderKinematicPair.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_LowOrderKinematicPair, StepKinematics_KinematicPair)
+
+//=======================================================================
+//function : StepKinematics_LowOrderKinematicPair
+//purpose :
+//=======================================================================
+StepKinematics_LowOrderKinematicPair::StepKinematics_LowOrderKinematicPair ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_LowOrderKinematicPair::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Boolean theTX,
+ const Standard_Boolean theTY,
+ const Standard_Boolean theTZ,
+ const Standard_Boolean theRX,
+ const Standard_Boolean theRY,
+ const Standard_Boolean theRZ)
+{
+ StepKinematics_KinematicPair::Init(theRepresentationItem_Name,
+ theItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2,
+ theKinematicPair_Joint);
+
+ myTX = theTX;
+
+ myTY = theTY;
+
+ myTZ = theTZ;
+
+ myRX = theRX;
+
+ myRY = theRY;
+
+ myRZ = theRZ;
+}
+
+//=======================================================================
+//function : TX
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_LowOrderKinematicPair::TX () const
+{
+ return myTX;
+}
+
+//=======================================================================
+//function : SetTX
+//purpose :
+//=======================================================================
+void StepKinematics_LowOrderKinematicPair::SetTX (const Standard_Boolean theTX)
+{
+ myTX = theTX;
+}
+
+//=======================================================================
+//function : TY
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_LowOrderKinematicPair::TY () const
+{
+ return myTY;
+}
+
+//=======================================================================
+//function : SetTY
+//purpose :
+//=======================================================================
+void StepKinematics_LowOrderKinematicPair::SetTY (const Standard_Boolean theTY)
+{
+ myTY = theTY;
+}
+
+//=======================================================================
+//function : TZ
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_LowOrderKinematicPair::TZ () const
+{
+ return myTZ;
+}
+
+//=======================================================================
+//function : SetTZ
+//purpose :
+//=======================================================================
+void StepKinematics_LowOrderKinematicPair::SetTZ (const Standard_Boolean theTZ)
+{
+ myTZ = theTZ;
+}
+
+//=======================================================================
+//function : RX
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_LowOrderKinematicPair::RX () const
+{
+ return myRX;
+}
+
+//=======================================================================
+//function : SetRX
+//purpose :
+//=======================================================================
+void StepKinematics_LowOrderKinematicPair::SetRX (const Standard_Boolean theRX)
+{
+ myRX = theRX;
+}
+
+//=======================================================================
+//function : RY
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_LowOrderKinematicPair::RY () const
+{
+ return myRY;
+}
+
+//=======================================================================
+//function : SetRY
+//purpose :
+//=======================================================================
+void StepKinematics_LowOrderKinematicPair::SetRY (const Standard_Boolean theRY)
+{
+ myRY = theRY;
+}
+
+//=======================================================================
+//function : RZ
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_LowOrderKinematicPair::RZ () const
+{
+ return myRZ;
+}
+
+//=======================================================================
+//function : SetRZ
+//purpose :
+//=======================================================================
+void StepKinematics_LowOrderKinematicPair::SetRZ (const Standard_Boolean theRZ)
+{
+ myRZ = theRZ;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_LowOrderKinematicPair_HeaderFile_
+#define _StepKinematics_LowOrderKinematicPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_LowOrderKinematicPair, StepKinematics_KinematicPair)
+
+//! Representation of STEP entity LowOrderKinematicPair
+class StepKinematics_LowOrderKinematicPair : public StepKinematics_KinematicPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_LowOrderKinematicPair();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Boolean theTX,
+ const Standard_Boolean theTY,
+ const Standard_Boolean theTZ,
+ const Standard_Boolean theRX,
+ const Standard_Boolean theRY,
+ const Standard_Boolean theRZ);
+
+ //! Returns field TX
+ Standard_EXPORT Standard_Boolean TX() const;
+ //! Sets field TX
+ Standard_EXPORT void SetTX (const Standard_Boolean theTX);
+
+ //! Returns field TY
+ Standard_EXPORT Standard_Boolean TY() const;
+ //! Sets field TY
+ Standard_EXPORT void SetTY (const Standard_Boolean theTY);
+
+ //! Returns field TZ
+ Standard_EXPORT Standard_Boolean TZ() const;
+ //! Sets field TZ
+ Standard_EXPORT void SetTZ (const Standard_Boolean theTZ);
+
+ //! Returns field RX
+ Standard_EXPORT Standard_Boolean RX() const;
+ //! Sets field RX
+ Standard_EXPORT void SetRX (const Standard_Boolean theRX);
+
+ //! Returns field RY
+ Standard_EXPORT Standard_Boolean RY() const;
+ //! Sets field RY
+ Standard_EXPORT void SetRY (const Standard_Boolean theRY);
+
+ //! Returns field RZ
+ Standard_EXPORT Standard_Boolean RZ() const;
+ //! Sets field RZ
+ Standard_EXPORT void SetRZ (const Standard_Boolean theRZ);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_LowOrderKinematicPair, StepKinematics_KinematicPair)
+
+private:
+ Standard_Boolean myTX;
+ Standard_Boolean myTY;
+ Standard_Boolean myTZ;
+ Standard_Boolean myRX;
+ Standard_Boolean myRY;
+ Standard_Boolean myRZ;
+
+};
+#endif // _StepKinematics_LowOrderKinematicPair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_LowOrderKinematicPairValue.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_LowOrderKinematicPairValue, StepKinematics_PairValue)
+
+//=======================================================================
+//function : StepKinematics_LowOrderKinematicPairValue
+//purpose :
+//=======================================================================
+StepKinematics_LowOrderKinematicPairValue::StepKinematics_LowOrderKinematicPairValue ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_LowOrderKinematicPairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Standard_Real theActualTranslationX,
+ const Standard_Real theActualTranslationY,
+ const Standard_Real theActualTranslationZ,
+ const Standard_Real theActualRotationX,
+ const Standard_Real theActualRotationY,
+ const Standard_Real theActualRotationZ)
+{
+ StepKinematics_PairValue::Init(theRepresentationItem_Name,
+ thePairValue_AppliesToPair);
+
+ myActualTranslationX = theActualTranslationX;
+
+ myActualTranslationY = theActualTranslationY;
+
+ myActualTranslationZ = theActualTranslationZ;
+
+ myActualRotationX = theActualRotationX;
+
+ myActualRotationY = theActualRotationY;
+
+ myActualRotationZ = theActualRotationZ;
+}
+
+//=======================================================================
+//function : ActualTranslationX
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_LowOrderKinematicPairValue::ActualTranslationX () const
+{
+ return myActualTranslationX;
+}
+
+//=======================================================================
+//function : SetActualTranslationX
+//purpose :
+//=======================================================================
+void StepKinematics_LowOrderKinematicPairValue::SetActualTranslationX (const Standard_Real theActualTranslationX)
+{
+ myActualTranslationX = theActualTranslationX;
+}
+
+//=======================================================================
+//function : ActualTranslationY
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_LowOrderKinematicPairValue::ActualTranslationY () const
+{
+ return myActualTranslationY;
+}
+
+//=======================================================================
+//function : SetActualTranslationY
+//purpose :
+//=======================================================================
+void StepKinematics_LowOrderKinematicPairValue::SetActualTranslationY (const Standard_Real theActualTranslationY)
+{
+ myActualTranslationY = theActualTranslationY;
+}
+
+//=======================================================================
+//function : ActualTranslationZ
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_LowOrderKinematicPairValue::ActualTranslationZ () const
+{
+ return myActualTranslationZ;
+}
+
+//=======================================================================
+//function : SetActualTranslationZ
+//purpose :
+//=======================================================================
+void StepKinematics_LowOrderKinematicPairValue::SetActualTranslationZ (const Standard_Real theActualTranslationZ)
+{
+ myActualTranslationZ = theActualTranslationZ;
+}
+
+//=======================================================================
+//function : ActualRotationX
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_LowOrderKinematicPairValue::ActualRotationX () const
+{
+ return myActualRotationX;
+}
+
+//=======================================================================
+//function : SetActualRotationX
+//purpose :
+//=======================================================================
+void StepKinematics_LowOrderKinematicPairValue::SetActualRotationX (const Standard_Real theActualRotationX)
+{
+ myActualRotationX = theActualRotationX;
+}
+
+//=======================================================================
+//function : ActualRotationY
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_LowOrderKinematicPairValue::ActualRotationY () const
+{
+ return myActualRotationY;
+}
+
+//=======================================================================
+//function : SetActualRotationY
+//purpose :
+//=======================================================================
+void StepKinematics_LowOrderKinematicPairValue::SetActualRotationY (const Standard_Real theActualRotationY)
+{
+ myActualRotationY = theActualRotationY;
+}
+
+//=======================================================================
+//function : ActualRotationZ
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_LowOrderKinematicPairValue::ActualRotationZ () const
+{
+ return myActualRotationZ;
+}
+
+//=======================================================================
+//function : SetActualRotationZ
+//purpose :
+//=======================================================================
+void StepKinematics_LowOrderKinematicPairValue::SetActualRotationZ (const Standard_Real theActualRotationZ)
+{
+ myActualRotationZ = theActualRotationZ;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_LowOrderKinematicPairValue_HeaderFile_
+#define _StepKinematics_LowOrderKinematicPairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_PairValue.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_LowOrderKinematicPairValue, StepKinematics_PairValue)
+
+//! Representation of STEP entity LowOrderKinematicPairValue
+class StepKinematics_LowOrderKinematicPairValue : public StepKinematics_PairValue
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_LowOrderKinematicPairValue();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Standard_Real theActualTranslationX,
+ const Standard_Real theActualTranslationY,
+ const Standard_Real theActualTranslationZ,
+ const Standard_Real theActualRotationX,
+ const Standard_Real theActualRotationY,
+ const Standard_Real theActualRotationZ);
+
+ //! Returns field ActualTranslationX
+ Standard_EXPORT Standard_Real ActualTranslationX() const;
+ //! Sets field ActualTranslationX
+ Standard_EXPORT void SetActualTranslationX (const Standard_Real theActualTranslationX);
+
+ //! Returns field ActualTranslationY
+ Standard_EXPORT Standard_Real ActualTranslationY() const;
+ //! Sets field ActualTranslationY
+ Standard_EXPORT void SetActualTranslationY (const Standard_Real theActualTranslationY);
+
+ //! Returns field ActualTranslationZ
+ Standard_EXPORT Standard_Real ActualTranslationZ() const;
+ //! Sets field ActualTranslationZ
+ Standard_EXPORT void SetActualTranslationZ (const Standard_Real theActualTranslationZ);
+
+ //! Returns field ActualRotationX
+ Standard_EXPORT Standard_Real ActualRotationX() const;
+ //! Sets field ActualRotationX
+ Standard_EXPORT void SetActualRotationX (const Standard_Real theActualRotationX);
+
+ //! Returns field ActualRotationY
+ Standard_EXPORT Standard_Real ActualRotationY() const;
+ //! Sets field ActualRotationY
+ Standard_EXPORT void SetActualRotationY (const Standard_Real theActualRotationY);
+
+ //! Returns field ActualRotationZ
+ Standard_EXPORT Standard_Real ActualRotationZ() const;
+ //! Sets field ActualRotationZ
+ Standard_EXPORT void SetActualRotationZ (const Standard_Real theActualRotationZ);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_LowOrderKinematicPairValue, StepKinematics_PairValue)
+
+private:
+ Standard_Real myActualTranslationX;
+ Standard_Real myActualTranslationY;
+ Standard_Real myActualTranslationZ;
+ Standard_Real myActualRotationX;
+ Standard_Real myActualRotationY;
+ Standard_Real myActualRotationZ;
+
+};
+#endif // _StepKinematics_LowOrderKinematicPairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_LowOrderKinematicPairWithMotionCoupling.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_LowOrderKinematicPairWithMotionCoupling, StepKinematics_KinematicPair)
+
+//=======================================================================
+//function : StepKinematics_LowOrderKinematicPairWithMotionCoupling
+//purpose :
+//=======================================================================
+StepKinematics_LowOrderKinematicPairWithMotionCoupling::StepKinematics_LowOrderKinematicPairWithMotionCoupling ()
+{
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_LowOrderKinematicPairWithMotionCoupling_HeaderFile_
+#define _StepKinematics_LowOrderKinematicPairWithMotionCoupling_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_LowOrderKinematicPairWithMotionCoupling, StepKinematics_KinematicPair)
+
+//! Representation of STEP entity LowOrderKinematicPairWithMotionCoupling
+class StepKinematics_LowOrderKinematicPairWithMotionCoupling : public StepKinematics_KinematicPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_LowOrderKinematicPairWithMotionCoupling();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_LowOrderKinematicPairWithMotionCoupling, StepKinematics_KinematicPair)
+
+};
+#endif // _StepKinematics_LowOrderKinematicPairWithMotionCoupling_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_LowOrderKinematicPairWithRange.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_LowOrderKinematicPairWithRange, StepKinematics_LowOrderKinematicPair)
+
+//=======================================================================
+//function : StepKinematics_LowOrderKinematicPairWithRange
+//purpose :
+//=======================================================================
+StepKinematics_LowOrderKinematicPairWithRange::StepKinematics_LowOrderKinematicPairWithRange ()
+{
+ defLowerLimitActualRotationX = Standard_False;
+ defUpperLimitActualRotationX = Standard_False;
+ defLowerLimitActualRotationY = Standard_False;
+ defUpperLimitActualRotationY = Standard_False;
+ defLowerLimitActualRotationZ = Standard_False;
+ defUpperLimitActualRotationZ = Standard_False;
+ defLowerLimitActualTranslationX = Standard_False;
+ defUpperLimitActualTranslationX = Standard_False;
+ defLowerLimitActualTranslationY = Standard_False;
+ defUpperLimitActualTranslationY = Standard_False;
+ defLowerLimitActualTranslationZ = Standard_False;
+ defUpperLimitActualTranslationZ = Standard_False;
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_LowOrderKinematicPairWithRange::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Boolean theLowOrderKinematicPair_TX,
+ const Standard_Boolean theLowOrderKinematicPair_TY,
+ const Standard_Boolean theLowOrderKinematicPair_TZ,
+ const Standard_Boolean theLowOrderKinematicPair_RX,
+ const Standard_Boolean theLowOrderKinematicPair_RY,
+ const Standard_Boolean theLowOrderKinematicPair_RZ,
+ const Standard_Boolean hasLowerLimitActualRotationX,
+ const Standard_Real theLowerLimitActualRotationX,
+ const Standard_Boolean hasUpperLimitActualRotationX,
+ const Standard_Real theUpperLimitActualRotationX,
+ const Standard_Boolean hasLowerLimitActualRotationY,
+ const Standard_Real theLowerLimitActualRotationY,
+ const Standard_Boolean hasUpperLimitActualRotationY,
+ const Standard_Real theUpperLimitActualRotationY,
+ const Standard_Boolean hasLowerLimitActualRotationZ,
+ const Standard_Real theLowerLimitActualRotationZ,
+ const Standard_Boolean hasUpperLimitActualRotationZ,
+ const Standard_Real theUpperLimitActualRotationZ,
+ const Standard_Boolean hasLowerLimitActualTranslationX,
+ const Standard_Real theLowerLimitActualTranslationX,
+ const Standard_Boolean hasUpperLimitActualTranslationX,
+ const Standard_Real theUpperLimitActualTranslationX,
+ const Standard_Boolean hasLowerLimitActualTranslationY,
+ const Standard_Real theLowerLimitActualTranslationY,
+ const Standard_Boolean hasUpperLimitActualTranslationY,
+ const Standard_Real theUpperLimitActualTranslationY,
+ const Standard_Boolean hasLowerLimitActualTranslationZ,
+ const Standard_Real theLowerLimitActualTranslationZ,
+ const Standard_Boolean hasUpperLimitActualTranslationZ,
+ const Standard_Real theUpperLimitActualTranslationZ)
+{
+ StepKinematics_LowOrderKinematicPair::Init(theRepresentationItem_Name,
+ theItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2,
+ theKinematicPair_Joint,
+ theLowOrderKinematicPair_TX,
+ theLowOrderKinematicPair_TY,
+ theLowOrderKinematicPair_TZ,
+ theLowOrderKinematicPair_RX,
+ theLowOrderKinematicPair_RY,
+ theLowOrderKinematicPair_RZ);
+
+ defLowerLimitActualRotationX = hasLowerLimitActualRotationX;
+ if (defLowerLimitActualRotationX) {
+ myLowerLimitActualRotationX = theLowerLimitActualRotationX;
+ }
+ else myLowerLimitActualRotationX = 0;
+
+ defUpperLimitActualRotationX = hasUpperLimitActualRotationX;
+ if (defUpperLimitActualRotationX) {
+ myUpperLimitActualRotationX = theUpperLimitActualRotationX;
+ }
+ else myUpperLimitActualRotationX = 0;
+
+ defLowerLimitActualRotationY = hasLowerLimitActualRotationY;
+ if (defLowerLimitActualRotationY) {
+ myLowerLimitActualRotationY = theLowerLimitActualRotationY;
+ }
+ else myLowerLimitActualRotationY = 0;
+
+ defUpperLimitActualRotationY = hasUpperLimitActualRotationY;
+ if (defUpperLimitActualRotationY) {
+ myUpperLimitActualRotationY = theUpperLimitActualRotationY;
+ }
+ else myUpperLimitActualRotationY = 0;
+
+ defLowerLimitActualRotationZ = hasLowerLimitActualRotationZ;
+ if (defLowerLimitActualRotationZ) {
+ myLowerLimitActualRotationZ = theLowerLimitActualRotationZ;
+ }
+ else myLowerLimitActualRotationZ = 0;
+
+ defUpperLimitActualRotationZ = hasUpperLimitActualRotationZ;
+ if (defUpperLimitActualRotationZ) {
+ myUpperLimitActualRotationZ = theUpperLimitActualRotationZ;
+ }
+ else myUpperLimitActualRotationZ = 0;
+
+ defLowerLimitActualTranslationX = hasLowerLimitActualTranslationX;
+ if (defLowerLimitActualTranslationX) {
+ myLowerLimitActualTranslationX = theLowerLimitActualTranslationX;
+ }
+ else myLowerLimitActualTranslationX = 0;
+
+ defUpperLimitActualTranslationX = hasUpperLimitActualTranslationX;
+ if (defUpperLimitActualTranslationX) {
+ myUpperLimitActualTranslationX = theUpperLimitActualTranslationX;
+ }
+ else myUpperLimitActualTranslationX = 0;
+
+ defLowerLimitActualTranslationY = hasLowerLimitActualTranslationY;
+ if (defLowerLimitActualTranslationY) {
+ myLowerLimitActualTranslationY = theLowerLimitActualTranslationY;
+ }
+ else myLowerLimitActualTranslationY = 0;
+
+ defUpperLimitActualTranslationY = hasUpperLimitActualTranslationY;
+ if (defUpperLimitActualTranslationY) {
+ myUpperLimitActualTranslationY = theUpperLimitActualTranslationY;
+ }
+ else myUpperLimitActualTranslationY = 0;
+
+ defLowerLimitActualTranslationZ = hasLowerLimitActualTranslationZ;
+ if (defLowerLimitActualTranslationZ) {
+ myLowerLimitActualTranslationZ = theLowerLimitActualTranslationZ;
+ }
+ else myLowerLimitActualTranslationZ = 0;
+
+ defUpperLimitActualTranslationZ = hasUpperLimitActualTranslationZ;
+ if (defUpperLimitActualTranslationZ) {
+ myUpperLimitActualTranslationZ = theUpperLimitActualTranslationZ;
+ }
+ else myUpperLimitActualTranslationZ = 0;
+}
+
+//=======================================================================
+//function : LowerLimitActualRotationX
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_LowOrderKinematicPairWithRange::LowerLimitActualRotationX () const
+{
+ return myLowerLimitActualRotationX;
+}
+
+//=======================================================================
+//function : SetLowerLimitActualRotationX
+//purpose :
+//=======================================================================
+void StepKinematics_LowOrderKinematicPairWithRange::SetLowerLimitActualRotationX (const Standard_Real theLowerLimitActualRotationX)
+{
+ myLowerLimitActualRotationX = theLowerLimitActualRotationX;
+}
+
+//=======================================================================
+//function : HasLowerLimitActualRotationX
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_LowOrderKinematicPairWithRange::HasLowerLimitActualRotationX () const
+{
+ return defLowerLimitActualRotationX;
+}
+
+//=======================================================================
+//function : UpperLimitActualRotationX
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_LowOrderKinematicPairWithRange::UpperLimitActualRotationX () const
+{
+ return myUpperLimitActualRotationX;
+}
+
+//=======================================================================
+//function : SetUpperLimitActualRotationX
+//purpose :
+//=======================================================================
+void StepKinematics_LowOrderKinematicPairWithRange::SetUpperLimitActualRotationX (const Standard_Real theUpperLimitActualRotationX)
+{
+ myUpperLimitActualRotationX = theUpperLimitActualRotationX;
+}
+
+//=======================================================================
+//function : HasUpperLimitActualRotationX
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_LowOrderKinematicPairWithRange::HasUpperLimitActualRotationX () const
+{
+ return defUpperLimitActualRotationX;
+}
+
+//=======================================================================
+//function : LowerLimitActualRotationY
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_LowOrderKinematicPairWithRange::LowerLimitActualRotationY () const
+{
+ return myLowerLimitActualRotationY;
+}
+
+//=======================================================================
+//function : SetLowerLimitActualRotationY
+//purpose :
+//=======================================================================
+void StepKinematics_LowOrderKinematicPairWithRange::SetLowerLimitActualRotationY (const Standard_Real theLowerLimitActualRotationY)
+{
+ myLowerLimitActualRotationY = theLowerLimitActualRotationY;
+}
+
+//=======================================================================
+//function : HasLowerLimitActualRotationY
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_LowOrderKinematicPairWithRange::HasLowerLimitActualRotationY () const
+{
+ return defLowerLimitActualRotationY;
+}
+
+//=======================================================================
+//function : UpperLimitActualRotationY
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_LowOrderKinematicPairWithRange::UpperLimitActualRotationY () const
+{
+ return myUpperLimitActualRotationY;
+}
+
+//=======================================================================
+//function : SetUpperLimitActualRotationY
+//purpose :
+//=======================================================================
+void StepKinematics_LowOrderKinematicPairWithRange::SetUpperLimitActualRotationY (const Standard_Real theUpperLimitActualRotationY)
+{
+ myUpperLimitActualRotationY = theUpperLimitActualRotationY;
+}
+
+//=======================================================================
+//function : HasUpperLimitActualRotationY
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_LowOrderKinematicPairWithRange::HasUpperLimitActualRotationY () const
+{
+ return defUpperLimitActualRotationY;
+}
+
+//=======================================================================
+//function : LowerLimitActualRotationZ
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_LowOrderKinematicPairWithRange::LowerLimitActualRotationZ () const
+{
+ return myLowerLimitActualRotationZ;
+}
+
+//=======================================================================
+//function : SetLowerLimitActualRotationZ
+//purpose :
+//=======================================================================
+void StepKinematics_LowOrderKinematicPairWithRange::SetLowerLimitActualRotationZ (const Standard_Real theLowerLimitActualRotationZ)
+{
+ myLowerLimitActualRotationZ = theLowerLimitActualRotationZ;
+}
+
+//=======================================================================
+//function : HasLowerLimitActualRotationZ
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_LowOrderKinematicPairWithRange::HasLowerLimitActualRotationZ () const
+{
+ return defLowerLimitActualRotationZ;
+}
+
+//=======================================================================
+//function : UpperLimitActualRotationZ
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_LowOrderKinematicPairWithRange::UpperLimitActualRotationZ () const
+{
+ return myUpperLimitActualRotationZ;
+}
+
+//=======================================================================
+//function : SetUpperLimitActualRotationZ
+//purpose :
+//=======================================================================
+void StepKinematics_LowOrderKinematicPairWithRange::SetUpperLimitActualRotationZ (const Standard_Real theUpperLimitActualRotationZ)
+{
+ myUpperLimitActualRotationZ = theUpperLimitActualRotationZ;
+}
+
+//=======================================================================
+//function : HasUpperLimitActualRotationZ
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_LowOrderKinematicPairWithRange::HasUpperLimitActualRotationZ () const
+{
+ return defUpperLimitActualRotationZ;
+}
+
+//=======================================================================
+//function : LowerLimitActualTranslationX
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_LowOrderKinematicPairWithRange::LowerLimitActualTranslationX () const
+{
+ return myLowerLimitActualTranslationX;
+}
+
+//=======================================================================
+//function : SetLowerLimitActualTranslationX
+//purpose :
+//=======================================================================
+void StepKinematics_LowOrderKinematicPairWithRange::SetLowerLimitActualTranslationX (const Standard_Real theLowerLimitActualTranslationX)
+{
+ myLowerLimitActualTranslationX = theLowerLimitActualTranslationX;
+}
+
+//=======================================================================
+//function : HasLowerLimitActualTranslationX
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_LowOrderKinematicPairWithRange::HasLowerLimitActualTranslationX () const
+{
+ return defLowerLimitActualTranslationX;
+}
+
+//=======================================================================
+//function : UpperLimitActualTranslationX
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_LowOrderKinematicPairWithRange::UpperLimitActualTranslationX () const
+{
+ return myUpperLimitActualTranslationX;
+}
+
+//=======================================================================
+//function : SetUpperLimitActualTranslationX
+//purpose :
+//=======================================================================
+void StepKinematics_LowOrderKinematicPairWithRange::SetUpperLimitActualTranslationX (const Standard_Real theUpperLimitActualTranslationX)
+{
+ myUpperLimitActualTranslationX = theUpperLimitActualTranslationX;
+}
+
+//=======================================================================
+//function : HasUpperLimitActualTranslationX
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_LowOrderKinematicPairWithRange::HasUpperLimitActualTranslationX () const
+{
+ return defUpperLimitActualTranslationX;
+}
+
+//=======================================================================
+//function : LowerLimitActualTranslationY
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_LowOrderKinematicPairWithRange::LowerLimitActualTranslationY () const
+{
+ return myLowerLimitActualTranslationY;
+}
+
+//=======================================================================
+//function : SetLowerLimitActualTranslationY
+//purpose :
+//=======================================================================
+void StepKinematics_LowOrderKinematicPairWithRange::SetLowerLimitActualTranslationY (const Standard_Real theLowerLimitActualTranslationY)
+{
+ myLowerLimitActualTranslationY = theLowerLimitActualTranslationY;
+}
+
+//=======================================================================
+//function : HasLowerLimitActualTranslationY
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_LowOrderKinematicPairWithRange::HasLowerLimitActualTranslationY () const
+{
+ return defLowerLimitActualTranslationY;
+}
+
+//=======================================================================
+//function : UpperLimitActualTranslationY
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_LowOrderKinematicPairWithRange::UpperLimitActualTranslationY () const
+{
+ return myUpperLimitActualTranslationY;
+}
+
+//=======================================================================
+//function : SetUpperLimitActualTranslationY
+//purpose :
+//=======================================================================
+void StepKinematics_LowOrderKinematicPairWithRange::SetUpperLimitActualTranslationY (const Standard_Real theUpperLimitActualTranslationY)
+{
+ myUpperLimitActualTranslationY = theUpperLimitActualTranslationY;
+}
+
+//=======================================================================
+//function : HasUpperLimitActualTranslationY
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_LowOrderKinematicPairWithRange::HasUpperLimitActualTranslationY () const
+{
+ return defUpperLimitActualTranslationY;
+}
+
+//=======================================================================
+//function : LowerLimitActualTranslationZ
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_LowOrderKinematicPairWithRange::LowerLimitActualTranslationZ () const
+{
+ return myLowerLimitActualTranslationZ;
+}
+
+//=======================================================================
+//function : SetLowerLimitActualTranslationZ
+//purpose :
+//=======================================================================
+void StepKinematics_LowOrderKinematicPairWithRange::SetLowerLimitActualTranslationZ (const Standard_Real theLowerLimitActualTranslationZ)
+{
+ myLowerLimitActualTranslationZ = theLowerLimitActualTranslationZ;
+}
+
+//=======================================================================
+//function : HasLowerLimitActualTranslationZ
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_LowOrderKinematicPairWithRange::HasLowerLimitActualTranslationZ () const
+{
+ return defLowerLimitActualTranslationZ;
+}
+
+//=======================================================================
+//function : UpperLimitActualTranslationZ
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_LowOrderKinematicPairWithRange::UpperLimitActualTranslationZ () const
+{
+ return myUpperLimitActualTranslationZ;
+}
+
+//=======================================================================
+//function : SetUpperLimitActualTranslationZ
+//purpose :
+//=======================================================================
+void StepKinematics_LowOrderKinematicPairWithRange::SetUpperLimitActualTranslationZ (const Standard_Real theUpperLimitActualTranslationZ)
+{
+ myUpperLimitActualTranslationZ = theUpperLimitActualTranslationZ;
+}
+
+//=======================================================================
+//function : HasUpperLimitActualTranslationZ
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_LowOrderKinematicPairWithRange::HasUpperLimitActualTranslationZ () const
+{
+ return defUpperLimitActualTranslationZ;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_LowOrderKinematicPairWithRange_HeaderFile_
+#define _StepKinematics_LowOrderKinematicPairWithRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_LowOrderKinematicPair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_LowOrderKinematicPairWithRange, StepKinematics_LowOrderKinematicPair)
+
+//! Representation of STEP entity LowOrderKinematicPairWithRange
+class StepKinematics_LowOrderKinematicPairWithRange : public StepKinematics_LowOrderKinematicPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_LowOrderKinematicPairWithRange();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Boolean theLowOrderKinematicPair_TX,
+ const Standard_Boolean theLowOrderKinematicPair_TY,
+ const Standard_Boolean theLowOrderKinematicPair_TZ,
+ const Standard_Boolean theLowOrderKinematicPair_RX,
+ const Standard_Boolean theLowOrderKinematicPair_RY,
+ const Standard_Boolean theLowOrderKinematicPair_RZ,
+ const Standard_Boolean hasLowerLimitActualRotationX,
+ const Standard_Real theLowerLimitActualRotationX,
+ const Standard_Boolean hasUpperLimitActualRotationX,
+ const Standard_Real theUpperLimitActualRotationX,
+ const Standard_Boolean hasLowerLimitActualRotationY,
+ const Standard_Real theLowerLimitActualRotationY,
+ const Standard_Boolean hasUpperLimitActualRotationY,
+ const Standard_Real theUpperLimitActualRotationY,
+ const Standard_Boolean hasLowerLimitActualRotationZ,
+ const Standard_Real theLowerLimitActualRotationZ,
+ const Standard_Boolean hasUpperLimitActualRotationZ,
+ const Standard_Real theUpperLimitActualRotationZ,
+ const Standard_Boolean hasLowerLimitActualTranslationX,
+ const Standard_Real theLowerLimitActualTranslationX,
+ const Standard_Boolean hasUpperLimitActualTranslationX,
+ const Standard_Real theUpperLimitActualTranslationX,
+ const Standard_Boolean hasLowerLimitActualTranslationY,
+ const Standard_Real theLowerLimitActualTranslationY,
+ const Standard_Boolean hasUpperLimitActualTranslationY,
+ const Standard_Real theUpperLimitActualTranslationY,
+ const Standard_Boolean hasLowerLimitActualTranslationZ,
+ const Standard_Real theLowerLimitActualTranslationZ,
+ const Standard_Boolean hasUpperLimitActualTranslationZ,
+ const Standard_Real theUpperLimitActualTranslationZ);
+
+ //! Returns field LowerLimitActualRotationX
+ Standard_EXPORT Standard_Real LowerLimitActualRotationX() const;
+ //! Sets field LowerLimitActualRotationX
+ Standard_EXPORT void SetLowerLimitActualRotationX (const Standard_Real theLowerLimitActualRotationX);
+ //! Returns True if optional field LowerLimitActualRotationX is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitActualRotationX() const;
+
+ //! Returns field UpperLimitActualRotationX
+ Standard_EXPORT Standard_Real UpperLimitActualRotationX() const;
+ //! Sets field UpperLimitActualRotationX
+ Standard_EXPORT void SetUpperLimitActualRotationX (const Standard_Real theUpperLimitActualRotationX);
+ //! Returns True if optional field UpperLimitActualRotationX is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitActualRotationX() const;
+
+ //! Returns field LowerLimitActualRotationY
+ Standard_EXPORT Standard_Real LowerLimitActualRotationY() const;
+ //! Sets field LowerLimitActualRotationY
+ Standard_EXPORT void SetLowerLimitActualRotationY (const Standard_Real theLowerLimitActualRotationY);
+ //! Returns True if optional field LowerLimitActualRotationY is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitActualRotationY() const;
+
+ //! Returns field UpperLimitActualRotationY
+ Standard_EXPORT Standard_Real UpperLimitActualRotationY() const;
+ //! Sets field UpperLimitActualRotationY
+ Standard_EXPORT void SetUpperLimitActualRotationY (const Standard_Real theUpperLimitActualRotationY);
+ //! Returns True if optional field UpperLimitActualRotationY is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitActualRotationY() const;
+
+ //! Returns field LowerLimitActualRotationZ
+ Standard_EXPORT Standard_Real LowerLimitActualRotationZ() const;
+ //! Sets field LowerLimitActualRotationZ
+ Standard_EXPORT void SetLowerLimitActualRotationZ (const Standard_Real theLowerLimitActualRotationZ);
+ //! Returns True if optional field LowerLimitActualRotationZ is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitActualRotationZ() const;
+
+ //! Returns field UpperLimitActualRotationZ
+ Standard_EXPORT Standard_Real UpperLimitActualRotationZ() const;
+ //! Sets field UpperLimitActualRotationZ
+ Standard_EXPORT void SetUpperLimitActualRotationZ (const Standard_Real theUpperLimitActualRotationZ);
+ //! Returns True if optional field UpperLimitActualRotationZ is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitActualRotationZ() const;
+
+ //! Returns field LowerLimitActualTranslationX
+ Standard_EXPORT Standard_Real LowerLimitActualTranslationX() const;
+ //! Sets field LowerLimitActualTranslationX
+ Standard_EXPORT void SetLowerLimitActualTranslationX (const Standard_Real theLowerLimitActualTranslationX);
+ //! Returns True if optional field LowerLimitActualTranslationX is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitActualTranslationX() const;
+
+ //! Returns field UpperLimitActualTranslationX
+ Standard_EXPORT Standard_Real UpperLimitActualTranslationX() const;
+ //! Sets field UpperLimitActualTranslationX
+ Standard_EXPORT void SetUpperLimitActualTranslationX (const Standard_Real theUpperLimitActualTranslationX);
+ //! Returns True if optional field UpperLimitActualTranslationX is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitActualTranslationX() const;
+
+ //! Returns field LowerLimitActualTranslationY
+ Standard_EXPORT Standard_Real LowerLimitActualTranslationY() const;
+ //! Sets field LowerLimitActualTranslationY
+ Standard_EXPORT void SetLowerLimitActualTranslationY (const Standard_Real theLowerLimitActualTranslationY);
+ //! Returns True if optional field LowerLimitActualTranslationY is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitActualTranslationY() const;
+
+ //! Returns field UpperLimitActualTranslationY
+ Standard_EXPORT Standard_Real UpperLimitActualTranslationY() const;
+ //! Sets field UpperLimitActualTranslationY
+ Standard_EXPORT void SetUpperLimitActualTranslationY (const Standard_Real theUpperLimitActualTranslationY);
+ //! Returns True if optional field UpperLimitActualTranslationY is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitActualTranslationY() const;
+
+ //! Returns field LowerLimitActualTranslationZ
+ Standard_EXPORT Standard_Real LowerLimitActualTranslationZ() const;
+ //! Sets field LowerLimitActualTranslationZ
+ Standard_EXPORT void SetLowerLimitActualTranslationZ (const Standard_Real theLowerLimitActualTranslationZ);
+ //! Returns True if optional field LowerLimitActualTranslationZ is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitActualTranslationZ() const;
+
+ //! Returns field UpperLimitActualTranslationZ
+ Standard_EXPORT Standard_Real UpperLimitActualTranslationZ() const;
+ //! Sets field UpperLimitActualTranslationZ
+ Standard_EXPORT void SetUpperLimitActualTranslationZ (const Standard_Real theUpperLimitActualTranslationZ);
+ //! Returns True if optional field UpperLimitActualTranslationZ is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitActualTranslationZ() const;
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_LowOrderKinematicPairWithRange, StepKinematics_LowOrderKinematicPair)
+
+private:
+ Standard_Real myLowerLimitActualRotationX; //!< optional
+ Standard_Real myUpperLimitActualRotationX; //!< optional
+ Standard_Real myLowerLimitActualRotationY; //!< optional
+ Standard_Real myUpperLimitActualRotationY; //!< optional
+ Standard_Real myLowerLimitActualRotationZ; //!< optional
+ Standard_Real myUpperLimitActualRotationZ; //!< optional
+ Standard_Real myLowerLimitActualTranslationX; //!< optional
+ Standard_Real myUpperLimitActualTranslationX; //!< optional
+ Standard_Real myLowerLimitActualTranslationY; //!< optional
+ Standard_Real myUpperLimitActualTranslationY; //!< optional
+ Standard_Real myLowerLimitActualTranslationZ; //!< optional
+ Standard_Real myUpperLimitActualTranslationZ; //!< optional
+ Standard_Boolean defLowerLimitActualRotationX; //!< flag "is LowerLimitActualRotationX defined"
+ Standard_Boolean defUpperLimitActualRotationX; //!< flag "is UpperLimitActualRotationX defined"
+ Standard_Boolean defLowerLimitActualRotationY; //!< flag "is LowerLimitActualRotationY defined"
+ Standard_Boolean defUpperLimitActualRotationY; //!< flag "is UpperLimitActualRotationY defined"
+ Standard_Boolean defLowerLimitActualRotationZ; //!< flag "is LowerLimitActualRotationZ defined"
+ Standard_Boolean defUpperLimitActualRotationZ; //!< flag "is UpperLimitActualRotationZ defined"
+ Standard_Boolean defLowerLimitActualTranslationX; //!< flag "is LowerLimitActualTranslationX defined"
+ Standard_Boolean defUpperLimitActualTranslationX; //!< flag "is UpperLimitActualTranslationX defined"
+ Standard_Boolean defLowerLimitActualTranslationY; //!< flag "is LowerLimitActualTranslationY defined"
+ Standard_Boolean defUpperLimitActualTranslationY; //!< flag "is UpperLimitActualTranslationY defined"
+ Standard_Boolean defLowerLimitActualTranslationZ; //!< flag "is LowerLimitActualTranslationZ defined"
+ Standard_Boolean defUpperLimitActualTranslationZ; //!< flag "is UpperLimitActualTranslationZ defined"
+
+};
+#endif // _StepKinematics_LowOrderKinematicPairWithRange_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_MechanismRepresentation.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_MechanismRepresentation, StepRepr_Representation)
+
+//=======================================================================
+//function : StepKinematics_MechanismRepresentation
+//purpose :
+//=======================================================================
+StepKinematics_MechanismRepresentation::StepKinematics_MechanismRepresentation ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_MechanismRepresentation::Init (const Handle(TCollection_HAsciiString)& theRepresentation_Name,
+ const Handle(StepRepr_HArray1OfRepresentationItem)& theRepresentation_Items,
+ const Handle(StepRepr_RepresentationContext)& theRepresentation_ContextOfItems,
+ const StepKinematics_KinematicTopologyRepresentationSelect& theRepresentedTopology)
+{
+ StepRepr_Representation::Init(theRepresentation_Name,
+ theRepresentation_Items,
+ theRepresentation_ContextOfItems);
+
+ myRepresentedTopology = theRepresentedTopology;
+}
+
+//=======================================================================
+//function : RepresentedTopology
+//purpose :
+//=======================================================================
+StepKinematics_KinematicTopologyRepresentationSelect StepKinematics_MechanismRepresentation::RepresentedTopology () const
+{
+ return myRepresentedTopology;
+}
+
+//=======================================================================
+//function : SetRepresentedTopology
+//purpose :
+//=======================================================================
+void StepKinematics_MechanismRepresentation::SetRepresentedTopology (const StepKinematics_KinematicTopologyRepresentationSelect& theRepresentedTopology)
+{
+ myRepresentedTopology = theRepresentedTopology;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_MechanismRepresentation_HeaderFile_
+#define _StepKinematics_MechanismRepresentation_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepRepr_Representation.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_RepresentationContext.hxx>
+#include <StepKinematics_KinematicTopologyRepresentationSelect.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_MechanismRepresentation, StepRepr_Representation)
+
+//! Representation of STEP entity MechanismRepresentation
+class StepKinematics_MechanismRepresentation : public StepRepr_Representation
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_MechanismRepresentation();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentation_Name,
+ const Handle(StepRepr_HArray1OfRepresentationItem)& theRepresentation_Items,
+ const Handle(StepRepr_RepresentationContext)& theRepresentation_ContextOfItems,
+ const StepKinematics_KinematicTopologyRepresentationSelect& theRepresentedTopology);
+
+ //! Returns field RepresentedTopology
+ Standard_EXPORT StepKinematics_KinematicTopologyRepresentationSelect RepresentedTopology() const;
+ //! Sets field RepresentedTopology
+ Standard_EXPORT void SetRepresentedTopology (const StepKinematics_KinematicTopologyRepresentationSelect& theRepresentedTopology);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_MechanismRepresentation, StepRepr_Representation)
+
+private:
+ StepKinematics_KinematicTopologyRepresentationSelect myRepresentedTopology;
+
+};
+#endif // _StepKinematics_MechanismRepresentation_HeaderFile_
--- /dev/null
+// Created on: 2020-06-18
+// Created by: PASUKHIN DMITRY
+// Copyright (c) 2020 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+
+#include <Standard_Type.hxx>
+#include <StepKinematics_MechanismStateRepresentation.hxx>
+#include <StepKinematics_MechanismRepresentation.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_MechanismStateRepresentation, StepRepr_Representation)
+
+StepKinematics_MechanismStateRepresentation::StepKinematics_MechanismStateRepresentation() {}
+
+void StepKinematics_MechanismStateRepresentation::Init(const Handle(TCollection_HAsciiString)& theName,
+ const Handle(StepRepr_HArray1OfRepresentationItem)& theItems,
+ const Handle(StepRepr_RepresentationContext)& theContextOfItems,
+ const Handle(StepKinematics_MechanismRepresentation) theMechanism)
+{
+ StepRepr_Representation::Init(theName, theItems, theContextOfItems);
+ myRepresentedMechanism = theMechanism;
+}
+
+void StepKinematics_MechanismStateRepresentation::SetMechanism(const Handle(StepKinematics_MechanismRepresentation)& theMechanism)
+{
+ myRepresentedMechanism = theMechanism;
+}
+
+Handle(StepKinematics_MechanismRepresentation) StepKinematics_MechanismStateRepresentation::Mechanism() const
+{
+ return myRepresentedMechanism;
+}
\ No newline at end of file
--- /dev/null
+// Created on: 2020-06-18
+// Created by: PASUKHIN DMITRY
+// Copyright (c) 2020 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_MechanismStateRepresentation_HeaderFile
+#define _StepKinematics_MechanismStateRepresentation_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepRepr_Representation.hxx>
+
+class StepKinematics_MechanismRepresentation;
+
+class StepKinematics_MechanismStateRepresentation;
+DEFINE_STANDARD_HANDLE(StepKinematics_MechanismStateRepresentation, StepRepr_Representation)
+
+
+class StepKinematics_MechanismStateRepresentation : public StepRepr_Representation
+{
+public:
+
+ //! Returns a MechanismStateRepresentation
+ Standard_EXPORT StepKinematics_MechanismStateRepresentation();
+
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theName, const Handle(StepRepr_HArray1OfRepresentationItem)& theItems, const Handle(StepRepr_RepresentationContext)& theContextOfItems, const Handle(StepKinematics_MechanismRepresentation) theMechanism);
+
+ Standard_EXPORT void SetMechanism(const Handle(StepKinematics_MechanismRepresentation)& theMechanism);
+
+ Standard_EXPORT Handle(StepKinematics_MechanismRepresentation) Mechanism() const;
+
+private:
+ Handle(StepKinematics_MechanismRepresentation) myRepresentedMechanism;
+
+ DEFINE_STANDARD_RTTIEXT(StepKinematics_MechanismStateRepresentation,StepRepr_Representation)
+};
+
+#endif // _StepKinematics_MechanismStateRepresentation_HeaderFile
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_OrientedJoint.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_OrientedJoint, StepShape_OrientedEdge)
+
+//=======================================================================
+//function : StepKinematics_OrientedJoint
+//purpose :
+//=======================================================================
+StepKinematics_OrientedJoint::StepKinematics_OrientedJoint ()
+{
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_OrientedJoint_HeaderFile_
+#define _StepKinematics_OrientedJoint_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepShape_OrientedEdge.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepShape_Vertex.hxx>
+#include <StepShape_Edge.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_OrientedJoint, StepShape_OrientedEdge)
+
+//! Representation of STEP entity OrientedJoint
+class StepKinematics_OrientedJoint : public StepShape_OrientedEdge
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_OrientedJoint();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_OrientedJoint, StepShape_OrientedEdge)
+
+};
+#endif // _StepKinematics_OrientedJoint_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_PairRepresentationRelationship.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_PairRepresentationRelationship, StepGeom_GeometricRepresentationItem)
+
+//=======================================================================
+//function : StepKinematics_PairRepresentationRelationship
+//purpose :
+//=======================================================================
+StepKinematics_PairRepresentationRelationship::StepKinematics_PairRepresentationRelationship ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_PairRepresentationRelationship::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theRepresentationRelationship_Name,
+ const Standard_Boolean /*hasRepresentationRelationship_Description*/,
+ const Handle(TCollection_HAsciiString)& theRepresentationRelationship_Description,
+ const StepRepr_RepresentationOrRepresentationReference& theRepresentationRelationship_Rep1,
+ const StepRepr_RepresentationOrRepresentationReference& theRepresentationRelationship_Rep2,
+ const StepRepr_Transformation& theRepresentationRelationshipWithTransformation_TransformationOperator)
+{
+ StepGeom_GeometricRepresentationItem::Init(theRepresentationItem_Name);
+ myRepresentationRelationshipWithTransformation = new StepRepr_RepresentationRelationshipWithTransformation;
+ myRepresentationRelationshipWithTransformation->Init(theRepresentationRelationship_Name,
+ /*hasRepresentationRelationship_Description,*/
+ theRepresentationRelationship_Description,
+ theRepresentationRelationship_Rep1.Representation(),
+ theRepresentationRelationship_Rep2.Representation(),
+ theRepresentationRelationshipWithTransformation_TransformationOperator);
+}
+
+//=======================================================================
+//function : RepresentationRelationshipWithTransformation
+//purpose :
+//=======================================================================
+Handle(StepRepr_RepresentationRelationshipWithTransformation) StepKinematics_PairRepresentationRelationship::RepresentationRelationshipWithTransformation () const
+{
+ return myRepresentationRelationshipWithTransformation;
+}
+
+//=======================================================================
+//function : SetRepresentationRelationshipWithTransformation
+//purpose :
+//=======================================================================
+void StepKinematics_PairRepresentationRelationship::SetRepresentationRelationshipWithTransformation (const Handle(StepRepr_RepresentationRelationshipWithTransformation)& theRepresentationRelationshipWithTransformation)
+{
+ myRepresentationRelationshipWithTransformation = theRepresentationRelationshipWithTransformation;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_PairRepresentationRelationship_HeaderFile_
+#define _StepKinematics_PairRepresentationRelationship_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepGeom_GeometricRepresentationItem.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationOrRepresentationReference.hxx>
+#include <StepRepr_Transformation.hxx>
+#include <StepRepr_RepresentationRelationshipWithTransformation.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_PairRepresentationRelationship, StepGeom_GeometricRepresentationItem)
+
+//! Representation of STEP entity PairRepresentationRelationship
+class StepKinematics_PairRepresentationRelationship : public StepGeom_GeometricRepresentationItem
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_PairRepresentationRelationship();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theRepresentationRelationship_Name,
+ const Standard_Boolean hasRepresentationRelationship_Description,
+ const Handle(TCollection_HAsciiString)& theRepresentationRelationship_Description,
+ const StepRepr_RepresentationOrRepresentationReference& theRepresentationRelationship_Rep1,
+ const StepRepr_RepresentationOrRepresentationReference& theRepresentationRelationship_Rep2,
+ const StepRepr_Transformation& theRepresentationRelationshipWithTransformation_TransformationOperator);
+
+ //! Returns data for supertype RepresentationRelationshipWithTransformation
+ Standard_EXPORT Handle(StepRepr_RepresentationRelationshipWithTransformation) RepresentationRelationshipWithTransformation() const;
+ //! Sets data for supertype RepresentationRelationshipWithTransformation
+ Standard_EXPORT void SetRepresentationRelationshipWithTransformation (const Handle(StepRepr_RepresentationRelationshipWithTransformation)& theRepresentationRelationshipWithTransformation);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_PairRepresentationRelationship, StepGeom_GeometricRepresentationItem)
+
+private:
+ Handle(StepRepr_RepresentationRelationshipWithTransformation) myRepresentationRelationshipWithTransformation; //!< supertype
+
+};
+#endif // _StepKinematics_PairRepresentationRelationship_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_PairValue.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_PairValue, StepGeom_GeometricRepresentationItem)
+
+//=======================================================================
+//function : StepKinematics_PairValue
+//purpose :
+//=======================================================================
+StepKinematics_PairValue::StepKinematics_PairValue ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_PairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& theAppliesToPair)
+{
+ StepGeom_GeometricRepresentationItem::Init(theRepresentationItem_Name);
+
+ myAppliesToPair = theAppliesToPair;
+}
+
+//=======================================================================
+//function : AppliesToPair
+//purpose :
+//=======================================================================
+Handle(StepKinematics_KinematicPair) StepKinematics_PairValue::AppliesToPair () const
+{
+ return myAppliesToPair;
+}
+
+//=======================================================================
+//function : SetAppliesToPair
+//purpose :
+//=======================================================================
+void StepKinematics_PairValue::SetAppliesToPair (const Handle(StepKinematics_KinematicPair)& theAppliesToPair)
+{
+ myAppliesToPair = theAppliesToPair;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_PairValue_HeaderFile_
+#define _StepKinematics_PairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepGeom_GeometricRepresentationItem.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_PairValue, StepGeom_GeometricRepresentationItem)
+
+//! Representation of STEP entity PairValue
+class StepKinematics_PairValue : public StepGeom_GeometricRepresentationItem
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_PairValue();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& theAppliesToPair);
+
+ //! Returns field AppliesToPair
+ Standard_EXPORT Handle(StepKinematics_KinematicPair) AppliesToPair() const;
+ //! Sets field AppliesToPair
+ Standard_EXPORT void SetAppliesToPair (const Handle(StepKinematics_KinematicPair)& theAppliesToPair);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_PairValue, StepGeom_GeometricRepresentationItem)
+
+private:
+ Handle(StepKinematics_KinematicPair) myAppliesToPair;
+
+};
+#endif // _StepKinematics_PairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_PlanarCurvePair.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_PlanarCurvePair, StepKinematics_HighOrderKinematicPair)
+
+//=======================================================================
+//function : StepKinematics_PlanarCurvePair
+//purpose :
+//=======================================================================
+StepKinematics_PlanarCurvePair::StepKinematics_PlanarCurvePair ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_PlanarCurvePair::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Handle(StepGeom_Curve)& theCurve1,
+ const Handle(StepGeom_Curve)& theCurve2,
+ const Standard_Boolean theOrientation)
+{
+ StepKinematics_HighOrderKinematicPair::Init(theRepresentationItem_Name,
+ theItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2,
+ theKinematicPair_Joint);
+
+ myCurve1 = theCurve1;
+
+ myCurve2 = theCurve2;
+
+ myOrientation = theOrientation;
+}
+
+//=======================================================================
+//function : Curve1
+//purpose :
+//=======================================================================
+Handle(StepGeom_Curve) StepKinematics_PlanarCurvePair::Curve1 () const
+{
+ return myCurve1;
+}
+
+//=======================================================================
+//function : SetCurve1
+//purpose :
+//=======================================================================
+void StepKinematics_PlanarCurvePair::SetCurve1 (const Handle(StepGeom_Curve)& theCurve1)
+{
+ myCurve1 = theCurve1;
+}
+
+//=======================================================================
+//function : Curve2
+//purpose :
+//=======================================================================
+Handle(StepGeom_Curve) StepKinematics_PlanarCurvePair::Curve2 () const
+{
+ return myCurve2;
+}
+
+//=======================================================================
+//function : SetCurve2
+//purpose :
+//=======================================================================
+void StepKinematics_PlanarCurvePair::SetCurve2 (const Handle(StepGeom_Curve)& theCurve2)
+{
+ myCurve2 = theCurve2;
+}
+
+//=======================================================================
+//function : Orientation
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_PlanarCurvePair::Orientation () const
+{
+ return myOrientation;
+}
+
+//=======================================================================
+//function : SetOrientation
+//purpose :
+//=======================================================================
+void StepKinematics_PlanarCurvePair::SetOrientation (const Standard_Boolean theOrientation)
+{
+ myOrientation = theOrientation;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_PlanarCurvePair_HeaderFile_
+#define _StepKinematics_PlanarCurvePair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_HighOrderKinematicPair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Curve.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_PlanarCurvePair, StepKinematics_HighOrderKinematicPair)
+
+//! Representation of STEP entity PlanarCurvePair
+class StepKinematics_PlanarCurvePair : public StepKinematics_HighOrderKinematicPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_PlanarCurvePair();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Handle(StepGeom_Curve)& theCurve1,
+ const Handle(StepGeom_Curve)& theCurve2,
+ const Standard_Boolean theOrientation);
+
+ //! Returns field Curve1
+ Standard_EXPORT Handle(StepGeom_Curve) Curve1() const;
+ //! Sets field Curve1
+ Standard_EXPORT void SetCurve1 (const Handle(StepGeom_Curve)& theCurve1);
+
+ //! Returns field Curve2
+ Standard_EXPORT Handle(StepGeom_Curve) Curve2() const;
+ //! Sets field Curve2
+ Standard_EXPORT void SetCurve2 (const Handle(StepGeom_Curve)& theCurve2);
+
+ //! Returns field Orientation
+ Standard_EXPORT Standard_Boolean Orientation() const;
+ //! Sets field Orientation
+ Standard_EXPORT void SetOrientation (const Standard_Boolean theOrientation);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_PlanarCurvePair, StepKinematics_HighOrderKinematicPair)
+
+private:
+ Handle(StepGeom_Curve) myCurve1;
+ Handle(StepGeom_Curve) myCurve2;
+ Standard_Boolean myOrientation;
+
+};
+#endif // _StepKinematics_PlanarCurvePair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_PlanarCurvePairRange.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_PlanarCurvePairRange, StepKinematics_PlanarCurvePair)
+
+//=======================================================================
+//function : StepKinematics_PlanarCurvePairRange
+//purpose :
+//=======================================================================
+StepKinematics_PlanarCurvePairRange::StepKinematics_PlanarCurvePairRange ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_PlanarCurvePairRange::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Handle(StepGeom_Curve)& thePlanarCurvePair_Curve1,
+ const Handle(StepGeom_Curve)& thePlanarCurvePair_Curve2,
+ const Standard_Boolean thePlanarCurvePair_Orientation,
+ const Handle(StepGeom_TrimmedCurve)& theRangeOnCurve1,
+ const Handle(StepGeom_TrimmedCurve)& theRangeOnCurve2)
+{
+ StepKinematics_PlanarCurvePair::Init(theRepresentationItem_Name,
+ theItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2,
+ theKinematicPair_Joint,
+ thePlanarCurvePair_Curve1,
+ thePlanarCurvePair_Curve2,
+ thePlanarCurvePair_Orientation);
+
+ myRangeOnCurve1 = theRangeOnCurve1;
+
+ myRangeOnCurve2 = theRangeOnCurve2;
+}
+
+//=======================================================================
+//function : RangeOnCurve1
+//purpose :
+//=======================================================================
+Handle(StepGeom_TrimmedCurve) StepKinematics_PlanarCurvePairRange::RangeOnCurve1 () const
+{
+ return myRangeOnCurve1;
+}
+
+//=======================================================================
+//function : SetRangeOnCurve1
+//purpose :
+//=======================================================================
+void StepKinematics_PlanarCurvePairRange::SetRangeOnCurve1 (const Handle(StepGeom_TrimmedCurve)& theRangeOnCurve1)
+{
+ myRangeOnCurve1 = theRangeOnCurve1;
+}
+
+//=======================================================================
+//function : RangeOnCurve2
+//purpose :
+//=======================================================================
+Handle(StepGeom_TrimmedCurve) StepKinematics_PlanarCurvePairRange::RangeOnCurve2 () const
+{
+ return myRangeOnCurve2;
+}
+
+//=======================================================================
+//function : SetRangeOnCurve2
+//purpose :
+//=======================================================================
+void StepKinematics_PlanarCurvePairRange::SetRangeOnCurve2 (const Handle(StepGeom_TrimmedCurve)& theRangeOnCurve2)
+{
+ myRangeOnCurve2 = theRangeOnCurve2;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_PlanarCurvePairRange_HeaderFile_
+#define _StepKinematics_PlanarCurvePairRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_PlanarCurvePair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Curve.hxx>
+#include <StepGeom_TrimmedCurve.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_PlanarCurvePairRange, StepKinematics_PlanarCurvePair)
+
+//! Representation of STEP entity PlanarCurvePairRange
+class StepKinematics_PlanarCurvePairRange : public StepKinematics_PlanarCurvePair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_PlanarCurvePairRange();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Handle(StepGeom_Curve)& thePlanarCurvePair_Curve1,
+ const Handle(StepGeom_Curve)& thePlanarCurvePair_Curve2,
+ const Standard_Boolean thePlanarCurvePair_Orientation,
+ const Handle(StepGeom_TrimmedCurve)& theRangeOnCurve1,
+ const Handle(StepGeom_TrimmedCurve)& theRangeOnCurve2);
+
+ //! Returns field RangeOnCurve1
+ Standard_EXPORT Handle(StepGeom_TrimmedCurve) RangeOnCurve1() const;
+ //! Sets field RangeOnCurve1
+ Standard_EXPORT void SetRangeOnCurve1 (const Handle(StepGeom_TrimmedCurve)& theRangeOnCurve1);
+
+ //! Returns field RangeOnCurve2
+ Standard_EXPORT Handle(StepGeom_TrimmedCurve) RangeOnCurve2() const;
+ //! Sets field RangeOnCurve2
+ Standard_EXPORT void SetRangeOnCurve2 (const Handle(StepGeom_TrimmedCurve)& theRangeOnCurve2);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_PlanarCurvePairRange, StepKinematics_PlanarCurvePair)
+
+private:
+ Handle(StepGeom_TrimmedCurve) myRangeOnCurve1;
+ Handle(StepGeom_TrimmedCurve) myRangeOnCurve2;
+
+};
+#endif // _StepKinematics_PlanarCurvePairRange_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_PlanarPair.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_PlanarPair, StepKinematics_LowOrderKinematicPair)
+
+//=======================================================================
+//function : StepKinematics_PlanarPair
+//purpose :
+//=======================================================================
+StepKinematics_PlanarPair::StepKinematics_PlanarPair ()
+{
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_PlanarPair_HeaderFile_
+#define _StepKinematics_PlanarPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_LowOrderKinematicPair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_PlanarPair, StepKinematics_LowOrderKinematicPair)
+
+//! Representation of STEP entity PlanarPair
+class StepKinematics_PlanarPair : public StepKinematics_LowOrderKinematicPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_PlanarPair();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_PlanarPair, StepKinematics_LowOrderKinematicPair)
+
+};
+#endif // _StepKinematics_PlanarPair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_PlanarPairValue.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_PlanarPairValue, StepKinematics_PairValue)
+
+//=======================================================================
+//function : StepKinematics_PlanarPairValue
+//purpose :
+//=======================================================================
+StepKinematics_PlanarPairValue::StepKinematics_PlanarPairValue ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_PlanarPairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Standard_Real theActualRotation,
+ const Standard_Real theActualTranslationX,
+ const Standard_Real theActualTranslationY)
+{
+ StepKinematics_PairValue::Init(theRepresentationItem_Name,
+ thePairValue_AppliesToPair);
+
+ myActualRotation = theActualRotation;
+
+ myActualTranslationX = theActualTranslationX;
+
+ myActualTranslationY = theActualTranslationY;
+}
+
+//=======================================================================
+//function : ActualRotation
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_PlanarPairValue::ActualRotation () const
+{
+ return myActualRotation;
+}
+
+//=======================================================================
+//function : SetActualRotation
+//purpose :
+//=======================================================================
+void StepKinematics_PlanarPairValue::SetActualRotation (const Standard_Real theActualRotation)
+{
+ myActualRotation = theActualRotation;
+}
+
+//=======================================================================
+//function : ActualTranslationX
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_PlanarPairValue::ActualTranslationX () const
+{
+ return myActualTranslationX;
+}
+
+//=======================================================================
+//function : SetActualTranslationX
+//purpose :
+//=======================================================================
+void StepKinematics_PlanarPairValue::SetActualTranslationX (const Standard_Real theActualTranslationX)
+{
+ myActualTranslationX = theActualTranslationX;
+}
+
+//=======================================================================
+//function : ActualTranslationY
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_PlanarPairValue::ActualTranslationY () const
+{
+ return myActualTranslationY;
+}
+
+//=======================================================================
+//function : SetActualTranslationY
+//purpose :
+//=======================================================================
+void StepKinematics_PlanarPairValue::SetActualTranslationY (const Standard_Real theActualTranslationY)
+{
+ myActualTranslationY = theActualTranslationY;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_PlanarPairValue_HeaderFile_
+#define _StepKinematics_PlanarPairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_PairValue.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_PlanarPairValue, StepKinematics_PairValue)
+
+//! Representation of STEP entity PlanarPairValue
+class StepKinematics_PlanarPairValue : public StepKinematics_PairValue
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_PlanarPairValue();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Standard_Real theActualRotation,
+ const Standard_Real theActualTranslationX,
+ const Standard_Real theActualTranslationY);
+
+ //! Returns field ActualRotation
+ Standard_EXPORT Standard_Real ActualRotation() const;
+ //! Sets field ActualRotation
+ Standard_EXPORT void SetActualRotation (const Standard_Real theActualRotation);
+
+ //! Returns field ActualTranslationX
+ Standard_EXPORT Standard_Real ActualTranslationX() const;
+ //! Sets field ActualTranslationX
+ Standard_EXPORT void SetActualTranslationX (const Standard_Real theActualTranslationX);
+
+ //! Returns field ActualTranslationY
+ Standard_EXPORT Standard_Real ActualTranslationY() const;
+ //! Sets field ActualTranslationY
+ Standard_EXPORT void SetActualTranslationY (const Standard_Real theActualTranslationY);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_PlanarPairValue, StepKinematics_PairValue)
+
+private:
+ Standard_Real myActualRotation;
+ Standard_Real myActualTranslationX;
+ Standard_Real myActualTranslationY;
+
+};
+#endif // _StepKinematics_PlanarPairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_PlanarPairWithRange.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_PlanarPairWithRange, StepKinematics_PlanarPair)
+
+//=======================================================================
+//function : StepKinematics_PlanarPairWithRange
+//purpose :
+//=======================================================================
+StepKinematics_PlanarPairWithRange::StepKinematics_PlanarPairWithRange ()
+{
+ defLowerLimitActualRotation = Standard_False;
+ defUpperLimitActualRotation = Standard_False;
+ defLowerLimitActualTranslationX = Standard_False;
+ defUpperLimitActualTranslationX = Standard_False;
+ defLowerLimitActualTranslationY = Standard_False;
+ defUpperLimitActualTranslationY = Standard_False;
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_PlanarPairWithRange::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Boolean theLowOrderKinematicPair_TX,
+ const Standard_Boolean theLowOrderKinematicPair_TY,
+ const Standard_Boolean theLowOrderKinematicPair_TZ,
+ const Standard_Boolean theLowOrderKinematicPair_RX,
+ const Standard_Boolean theLowOrderKinematicPair_RY,
+ const Standard_Boolean theLowOrderKinematicPair_RZ,
+ const Standard_Boolean hasLowerLimitActualRotation,
+ const Standard_Real theLowerLimitActualRotation,
+ const Standard_Boolean hasUpperLimitActualRotation,
+ const Standard_Real theUpperLimitActualRotation,
+ const Standard_Boolean hasLowerLimitActualTranslationX,
+ const Standard_Real theLowerLimitActualTranslationX,
+ const Standard_Boolean hasUpperLimitActualTranslationX,
+ const Standard_Real theUpperLimitActualTranslationX,
+ const Standard_Boolean hasLowerLimitActualTranslationY,
+ const Standard_Real theLowerLimitActualTranslationY,
+ const Standard_Boolean hasUpperLimitActualTranslationY,
+ const Standard_Real theUpperLimitActualTranslationY)
+{
+ StepKinematics_PlanarPair::Init(theRepresentationItem_Name,
+ theItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2,
+ theKinematicPair_Joint,
+ theLowOrderKinematicPair_TX,
+ theLowOrderKinematicPair_TY,
+ theLowOrderKinematicPair_TZ,
+ theLowOrderKinematicPair_RX,
+ theLowOrderKinematicPair_RY,
+ theLowOrderKinematicPair_RZ);
+
+ defLowerLimitActualRotation = hasLowerLimitActualRotation;
+ if (defLowerLimitActualRotation) {
+ myLowerLimitActualRotation = theLowerLimitActualRotation;
+ }
+ else myLowerLimitActualRotation = 0;
+
+ defUpperLimitActualRotation = hasUpperLimitActualRotation;
+ if (defUpperLimitActualRotation) {
+ myUpperLimitActualRotation = theUpperLimitActualRotation;
+ }
+ else myUpperLimitActualRotation = 0;
+
+ defLowerLimitActualTranslationX = hasLowerLimitActualTranslationX;
+ if (defLowerLimitActualTranslationX) {
+ myLowerLimitActualTranslationX = theLowerLimitActualTranslationX;
+ }
+ else myLowerLimitActualTranslationX = 0;
+
+ defUpperLimitActualTranslationX = hasUpperLimitActualTranslationX;
+ if (defUpperLimitActualTranslationX) {
+ myUpperLimitActualTranslationX = theUpperLimitActualTranslationX;
+ }
+ else myUpperLimitActualTranslationX = 0;
+
+ defLowerLimitActualTranslationY = hasLowerLimitActualTranslationY;
+ if (defLowerLimitActualTranslationY) {
+ myLowerLimitActualTranslationY = theLowerLimitActualTranslationY;
+ }
+ else myLowerLimitActualTranslationY = 0;
+
+ defUpperLimitActualTranslationY = hasUpperLimitActualTranslationY;
+ if (defUpperLimitActualTranslationY) {
+ myUpperLimitActualTranslationY = theUpperLimitActualTranslationY;
+ }
+ else myUpperLimitActualTranslationY = 0;
+}
+
+//=======================================================================
+//function : LowerLimitActualRotation
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_PlanarPairWithRange::LowerLimitActualRotation () const
+{
+ return myLowerLimitActualRotation;
+}
+
+//=======================================================================
+//function : SetLowerLimitActualRotation
+//purpose :
+//=======================================================================
+void StepKinematics_PlanarPairWithRange::SetLowerLimitActualRotation (const Standard_Real theLowerLimitActualRotation)
+{
+ myLowerLimitActualRotation = theLowerLimitActualRotation;
+}
+
+//=======================================================================
+//function : HasLowerLimitActualRotation
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_PlanarPairWithRange::HasLowerLimitActualRotation () const
+{
+ return defLowerLimitActualRotation;
+}
+
+//=======================================================================
+//function : UpperLimitActualRotation
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_PlanarPairWithRange::UpperLimitActualRotation () const
+{
+ return myUpperLimitActualRotation;
+}
+
+//=======================================================================
+//function : SetUpperLimitActualRotation
+//purpose :
+//=======================================================================
+void StepKinematics_PlanarPairWithRange::SetUpperLimitActualRotation (const Standard_Real theUpperLimitActualRotation)
+{
+ myUpperLimitActualRotation = theUpperLimitActualRotation;
+}
+
+//=======================================================================
+//function : HasUpperLimitActualRotation
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_PlanarPairWithRange::HasUpperLimitActualRotation () const
+{
+ return defUpperLimitActualRotation;
+}
+
+//=======================================================================
+//function : LowerLimitActualTranslationX
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_PlanarPairWithRange::LowerLimitActualTranslationX () const
+{
+ return myLowerLimitActualTranslationX;
+}
+
+//=======================================================================
+//function : SetLowerLimitActualTranslationX
+//purpose :
+//=======================================================================
+void StepKinematics_PlanarPairWithRange::SetLowerLimitActualTranslationX (const Standard_Real theLowerLimitActualTranslationX)
+{
+ myLowerLimitActualTranslationX = theLowerLimitActualTranslationX;
+}
+
+//=======================================================================
+//function : HasLowerLimitActualTranslationX
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_PlanarPairWithRange::HasLowerLimitActualTranslationX () const
+{
+ return defLowerLimitActualTranslationX;
+}
+
+//=======================================================================
+//function : UpperLimitActualTranslationX
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_PlanarPairWithRange::UpperLimitActualTranslationX () const
+{
+ return myUpperLimitActualTranslationX;
+}
+
+//=======================================================================
+//function : SetUpperLimitActualTranslationX
+//purpose :
+//=======================================================================
+void StepKinematics_PlanarPairWithRange::SetUpperLimitActualTranslationX (const Standard_Real theUpperLimitActualTranslationX)
+{
+ myUpperLimitActualTranslationX = theUpperLimitActualTranslationX;
+}
+
+//=======================================================================
+//function : HasUpperLimitActualTranslationX
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_PlanarPairWithRange::HasUpperLimitActualTranslationX () const
+{
+ return defUpperLimitActualTranslationX;
+}
+
+//=======================================================================
+//function : LowerLimitActualTranslationY
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_PlanarPairWithRange::LowerLimitActualTranslationY () const
+{
+ return myLowerLimitActualTranslationY;
+}
+
+//=======================================================================
+//function : SetLowerLimitActualTranslationY
+//purpose :
+//=======================================================================
+void StepKinematics_PlanarPairWithRange::SetLowerLimitActualTranslationY (const Standard_Real theLowerLimitActualTranslationY)
+{
+ myLowerLimitActualTranslationY = theLowerLimitActualTranslationY;
+}
+
+//=======================================================================
+//function : HasLowerLimitActualTranslationY
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_PlanarPairWithRange::HasLowerLimitActualTranslationY () const
+{
+ return defLowerLimitActualTranslationY;
+}
+
+//=======================================================================
+//function : UpperLimitActualTranslationY
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_PlanarPairWithRange::UpperLimitActualTranslationY () const
+{
+ return myUpperLimitActualTranslationY;
+}
+
+//=======================================================================
+//function : SetUpperLimitActualTranslationY
+//purpose :
+//=======================================================================
+void StepKinematics_PlanarPairWithRange::SetUpperLimitActualTranslationY (const Standard_Real theUpperLimitActualTranslationY)
+{
+ myUpperLimitActualTranslationY = theUpperLimitActualTranslationY;
+}
+
+//=======================================================================
+//function : HasUpperLimitActualTranslationY
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_PlanarPairWithRange::HasUpperLimitActualTranslationY () const
+{
+ return defUpperLimitActualTranslationY;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_PlanarPairWithRange_HeaderFile_
+#define _StepKinematics_PlanarPairWithRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_PlanarPair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_PlanarPairWithRange, StepKinematics_PlanarPair)
+
+//! Representation of STEP entity PlanarPairWithRange
+class StepKinematics_PlanarPairWithRange : public StepKinematics_PlanarPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_PlanarPairWithRange();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Boolean theLowOrderKinematicPair_TX,
+ const Standard_Boolean theLowOrderKinematicPair_TY,
+ const Standard_Boolean theLowOrderKinematicPair_TZ,
+ const Standard_Boolean theLowOrderKinematicPair_RX,
+ const Standard_Boolean theLowOrderKinematicPair_RY,
+ const Standard_Boolean theLowOrderKinematicPair_RZ,
+ const Standard_Boolean hasLowerLimitActualRotation,
+ const Standard_Real theLowerLimitActualRotation,
+ const Standard_Boolean hasUpperLimitActualRotation,
+ const Standard_Real theUpperLimitActualRotation,
+ const Standard_Boolean hasLowerLimitActualTranslationX,
+ const Standard_Real theLowerLimitActualTranslationX,
+ const Standard_Boolean hasUpperLimitActualTranslationX,
+ const Standard_Real theUpperLimitActualTranslationX,
+ const Standard_Boolean hasLowerLimitActualTranslationY,
+ const Standard_Real theLowerLimitActualTranslationY,
+ const Standard_Boolean hasUpperLimitActualTranslationY,
+ const Standard_Real theUpperLimitActualTranslationY);
+
+ //! Returns field LowerLimitActualRotation
+ Standard_EXPORT Standard_Real LowerLimitActualRotation() const;
+ //! Sets field LowerLimitActualRotation
+ Standard_EXPORT void SetLowerLimitActualRotation (const Standard_Real theLowerLimitActualRotation);
+ //! Returns True if optional field LowerLimitActualRotation is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitActualRotation() const;
+
+ //! Returns field UpperLimitActualRotation
+ Standard_EXPORT Standard_Real UpperLimitActualRotation() const;
+ //! Sets field UpperLimitActualRotation
+ Standard_EXPORT void SetUpperLimitActualRotation (const Standard_Real theUpperLimitActualRotation);
+ //! Returns True if optional field UpperLimitActualRotation is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitActualRotation() const;
+
+ //! Returns field LowerLimitActualTranslationX
+ Standard_EXPORT Standard_Real LowerLimitActualTranslationX() const;
+ //! Sets field LowerLimitActualTranslationX
+ Standard_EXPORT void SetLowerLimitActualTranslationX (const Standard_Real theLowerLimitActualTranslationX);
+ //! Returns True if optional field LowerLimitActualTranslationX is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitActualTranslationX() const;
+
+ //! Returns field UpperLimitActualTranslationX
+ Standard_EXPORT Standard_Real UpperLimitActualTranslationX() const;
+ //! Sets field UpperLimitActualTranslationX
+ Standard_EXPORT void SetUpperLimitActualTranslationX (const Standard_Real theUpperLimitActualTranslationX);
+ //! Returns True if optional field UpperLimitActualTranslationX is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitActualTranslationX() const;
+
+ //! Returns field LowerLimitActualTranslationY
+ Standard_EXPORT Standard_Real LowerLimitActualTranslationY() const;
+ //! Sets field LowerLimitActualTranslationY
+ Standard_EXPORT void SetLowerLimitActualTranslationY (const Standard_Real theLowerLimitActualTranslationY);
+ //! Returns True if optional field LowerLimitActualTranslationY is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitActualTranslationY() const;
+
+ //! Returns field UpperLimitActualTranslationY
+ Standard_EXPORT Standard_Real UpperLimitActualTranslationY() const;
+ //! Sets field UpperLimitActualTranslationY
+ Standard_EXPORT void SetUpperLimitActualTranslationY (const Standard_Real theUpperLimitActualTranslationY);
+ //! Returns True if optional field UpperLimitActualTranslationY is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitActualTranslationY() const;
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_PlanarPairWithRange, StepKinematics_PlanarPair)
+
+private:
+ Standard_Real myLowerLimitActualRotation; //!< optional
+ Standard_Real myUpperLimitActualRotation; //!< optional
+ Standard_Real myLowerLimitActualTranslationX; //!< optional
+ Standard_Real myUpperLimitActualTranslationX; //!< optional
+ Standard_Real myLowerLimitActualTranslationY; //!< optional
+ Standard_Real myUpperLimitActualTranslationY; //!< optional
+ Standard_Boolean defLowerLimitActualRotation; //!< flag "is LowerLimitActualRotation defined"
+ Standard_Boolean defUpperLimitActualRotation; //!< flag "is UpperLimitActualRotation defined"
+ Standard_Boolean defLowerLimitActualTranslationX; //!< flag "is LowerLimitActualTranslationX defined"
+ Standard_Boolean defUpperLimitActualTranslationX; //!< flag "is UpperLimitActualTranslationX defined"
+ Standard_Boolean defLowerLimitActualTranslationY; //!< flag "is LowerLimitActualTranslationY defined"
+ Standard_Boolean defUpperLimitActualTranslationY; //!< flag "is UpperLimitActualTranslationY defined"
+
+};
+#endif // _StepKinematics_PlanarPairWithRange_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_PointOnPlanarCurvePair.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_PointOnPlanarCurvePair, StepKinematics_HighOrderKinematicPair)
+
+//=======================================================================
+//function : StepKinematics_PointOnPlanarCurvePair
+//purpose :
+//=======================================================================
+StepKinematics_PointOnPlanarCurvePair::StepKinematics_PointOnPlanarCurvePair ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_PointOnPlanarCurvePair::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Handle(StepGeom_Curve)& thePairCurve,
+ const Standard_Boolean theOrientation)
+{
+ StepKinematics_HighOrderKinematicPair::Init(theRepresentationItem_Name,
+ theItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2,
+ theKinematicPair_Joint);
+
+ myPairCurve = thePairCurve;
+
+ myOrientation = theOrientation;
+}
+
+//=======================================================================
+//function : PairCurve
+//purpose :
+//=======================================================================
+Handle(StepGeom_Curve) StepKinematics_PointOnPlanarCurvePair::PairCurve () const
+{
+ return myPairCurve;
+}
+
+//=======================================================================
+//function : SetPairCurve
+//purpose :
+//=======================================================================
+void StepKinematics_PointOnPlanarCurvePair::SetPairCurve (const Handle(StepGeom_Curve)& thePairCurve)
+{
+ myPairCurve = thePairCurve;
+}
+
+//=======================================================================
+//function : Orientation
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_PointOnPlanarCurvePair::Orientation () const
+{
+ return myOrientation;
+}
+
+//=======================================================================
+//function : SetOrientation
+//purpose :
+//=======================================================================
+void StepKinematics_PointOnPlanarCurvePair::SetOrientation (const Standard_Boolean theOrientation)
+{
+ myOrientation = theOrientation;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_PointOnPlanarCurvePair_HeaderFile_
+#define _StepKinematics_PointOnPlanarCurvePair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_HighOrderKinematicPair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Curve.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_PointOnPlanarCurvePair, StepKinematics_HighOrderKinematicPair)
+
+//! Representation of STEP entity PointOnPlanarCurvePair
+class StepKinematics_PointOnPlanarCurvePair : public StepKinematics_HighOrderKinematicPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_PointOnPlanarCurvePair();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Handle(StepGeom_Curve)& thePairCurve,
+ const Standard_Boolean theOrientation);
+
+ //! Returns field PairCurve
+ Standard_EXPORT Handle(StepGeom_Curve) PairCurve() const;
+ //! Sets field PairCurve
+ Standard_EXPORT void SetPairCurve (const Handle(StepGeom_Curve)& thePairCurve);
+
+ //! Returns field Orientation
+ Standard_EXPORT Standard_Boolean Orientation() const;
+ //! Sets field Orientation
+ Standard_EXPORT void SetOrientation (const Standard_Boolean theOrientation);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_PointOnPlanarCurvePair, StepKinematics_HighOrderKinematicPair)
+
+private:
+ Handle(StepGeom_Curve) myPairCurve;
+ Standard_Boolean myOrientation;
+
+};
+#endif // _StepKinematics_PointOnPlanarCurvePair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_PointOnPlanarCurvePairValue.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_PointOnPlanarCurvePairValue, StepKinematics_PairValue)
+
+//=======================================================================
+//function : StepKinematics_PointOnPlanarCurvePairValue
+//purpose :
+//=======================================================================
+StepKinematics_PointOnPlanarCurvePairValue::StepKinematics_PointOnPlanarCurvePairValue ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_PointOnPlanarCurvePairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve,
+ const StepKinematics_SpatialRotation& theInputOrientation)
+{
+ StepKinematics_PairValue::Init(theRepresentationItem_Name,
+ thePairValue_AppliesToPair);
+
+ myActualPointOnCurve = theActualPointOnCurve;
+
+ myInputOrientation = theInputOrientation;
+}
+
+//=======================================================================
+//function : ActualPointOnCurve
+//purpose :
+//=======================================================================
+Handle(StepGeom_PointOnCurve) StepKinematics_PointOnPlanarCurvePairValue::ActualPointOnCurve () const
+{
+ return myActualPointOnCurve;
+}
+
+//=======================================================================
+//function : SetActualPointOnCurve
+//purpose :
+//=======================================================================
+void StepKinematics_PointOnPlanarCurvePairValue::SetActualPointOnCurve (const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve)
+{
+ myActualPointOnCurve = theActualPointOnCurve;
+}
+
+//=======================================================================
+//function : InputOrientation
+//purpose :
+//=======================================================================
+StepKinematics_SpatialRotation StepKinematics_PointOnPlanarCurvePairValue::InputOrientation () const
+{
+ return myInputOrientation;
+}
+
+//=======================================================================
+//function : SetInputOrientation
+//purpose :
+//=======================================================================
+void StepKinematics_PointOnPlanarCurvePairValue::SetInputOrientation (const StepKinematics_SpatialRotation& theInputOrientation)
+{
+ myInputOrientation = theInputOrientation;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_PointOnPlanarCurvePairValue_HeaderFile_
+#define _StepKinematics_PointOnPlanarCurvePairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_PairValue.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <StepGeom_PointOnCurve.hxx>
+#include <StepKinematics_SpatialRotation.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_PointOnPlanarCurvePairValue, StepKinematics_PairValue)
+
+//! Representation of STEP entity PointOnPlanarCurvePairValue
+class StepKinematics_PointOnPlanarCurvePairValue : public StepKinematics_PairValue
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_PointOnPlanarCurvePairValue();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve,
+ const StepKinematics_SpatialRotation& theInputOrientation);
+
+ //! Returns field ActualPointOnCurve
+ Standard_EXPORT Handle(StepGeom_PointOnCurve) ActualPointOnCurve() const;
+ //! Sets field ActualPointOnCurve
+ Standard_EXPORT void SetActualPointOnCurve (const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve);
+
+ //! Returns field InputOrientation
+ Standard_EXPORT StepKinematics_SpatialRotation InputOrientation() const;
+ //! Sets field InputOrientation
+ Standard_EXPORT void SetInputOrientation (const StepKinematics_SpatialRotation& theInputOrientation);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_PointOnPlanarCurvePairValue, StepKinematics_PairValue)
+
+private:
+ Handle(StepGeom_PointOnCurve) myActualPointOnCurve;
+ StepKinematics_SpatialRotation myInputOrientation;
+
+};
+#endif // _StepKinematics_PointOnPlanarCurvePairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_PointOnPlanarCurvePairWithRange.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_PointOnPlanarCurvePairWithRange, StepKinematics_PointOnPlanarCurvePair)
+
+//=======================================================================
+//function : StepKinematics_PointOnPlanarCurvePairWithRange
+//purpose :
+//=======================================================================
+StepKinematics_PointOnPlanarCurvePairWithRange::StepKinematics_PointOnPlanarCurvePairWithRange ()
+{
+ defLowerLimitYaw = Standard_False;
+ defUpperLimitYaw = Standard_False;
+ defLowerLimitPitch = Standard_False;
+ defUpperLimitPitch = Standard_False;
+ defLowerLimitRoll = Standard_False;
+ defUpperLimitRoll = Standard_False;
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_PointOnPlanarCurvePairWithRange::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Handle(StepGeom_Curve)& thePointOnPlanarCurvePair_PairCurve,
+ const Standard_Boolean thePointOnPlanarCurvePair_Orientation,
+ const Handle(StepGeom_TrimmedCurve)& theRangeOnPairCurve,
+ const Standard_Boolean hasLowerLimitYaw,
+ const Standard_Real theLowerLimitYaw,
+ const Standard_Boolean hasUpperLimitYaw,
+ const Standard_Real theUpperLimitYaw,
+ const Standard_Boolean hasLowerLimitPitch,
+ const Standard_Real theLowerLimitPitch,
+ const Standard_Boolean hasUpperLimitPitch,
+ const Standard_Real theUpperLimitPitch,
+ const Standard_Boolean hasLowerLimitRoll,
+ const Standard_Real theLowerLimitRoll,
+ const Standard_Boolean hasUpperLimitRoll,
+ const Standard_Real theUpperLimitRoll)
+{
+ StepKinematics_PointOnPlanarCurvePair::Init(theRepresentationItem_Name,
+ theItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2,
+ theKinematicPair_Joint,
+ thePointOnPlanarCurvePair_PairCurve,
+ thePointOnPlanarCurvePair_Orientation);
+
+ myRangeOnPairCurve = theRangeOnPairCurve;
+
+ defLowerLimitYaw = hasLowerLimitYaw;
+ if (defLowerLimitYaw) {
+ myLowerLimitYaw = theLowerLimitYaw;
+ }
+ else myLowerLimitYaw = 0;
+
+ defUpperLimitYaw = hasUpperLimitYaw;
+ if (defUpperLimitYaw) {
+ myUpperLimitYaw = theUpperLimitYaw;
+ }
+ else myUpperLimitYaw = 0;
+
+ defLowerLimitPitch = hasLowerLimitPitch;
+ if (defLowerLimitPitch) {
+ myLowerLimitPitch = theLowerLimitPitch;
+ }
+ else myLowerLimitPitch = 0;
+
+ defUpperLimitPitch = hasUpperLimitPitch;
+ if (defUpperLimitPitch) {
+ myUpperLimitPitch = theUpperLimitPitch;
+ }
+ else myUpperLimitPitch = 0;
+
+ defLowerLimitRoll = hasLowerLimitRoll;
+ if (defLowerLimitRoll) {
+ myLowerLimitRoll = theLowerLimitRoll;
+ }
+ else myLowerLimitRoll = 0;
+
+ defUpperLimitRoll = hasUpperLimitRoll;
+ if (defUpperLimitRoll) {
+ myUpperLimitRoll = theUpperLimitRoll;
+ }
+ else myUpperLimitRoll = 0;
+}
+
+//=======================================================================
+//function : RangeOnPairCurve
+//purpose :
+//=======================================================================
+Handle(StepGeom_TrimmedCurve) StepKinematics_PointOnPlanarCurvePairWithRange::RangeOnPairCurve () const
+{
+ return myRangeOnPairCurve;
+}
+
+//=======================================================================
+//function : SetRangeOnPairCurve
+//purpose :
+//=======================================================================
+void StepKinematics_PointOnPlanarCurvePairWithRange::SetRangeOnPairCurve (const Handle(StepGeom_TrimmedCurve)& theRangeOnPairCurve)
+{
+ myRangeOnPairCurve = theRangeOnPairCurve;
+}
+
+//=======================================================================
+//function : LowerLimitYaw
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_PointOnPlanarCurvePairWithRange::LowerLimitYaw () const
+{
+ return myLowerLimitYaw;
+}
+
+//=======================================================================
+//function : SetLowerLimitYaw
+//purpose :
+//=======================================================================
+void StepKinematics_PointOnPlanarCurvePairWithRange::SetLowerLimitYaw (const Standard_Real theLowerLimitYaw)
+{
+ myLowerLimitYaw = theLowerLimitYaw;
+}
+
+//=======================================================================
+//function : HasLowerLimitYaw
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_PointOnPlanarCurvePairWithRange::HasLowerLimitYaw () const
+{
+ return defLowerLimitYaw;
+}
+
+//=======================================================================
+//function : UpperLimitYaw
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_PointOnPlanarCurvePairWithRange::UpperLimitYaw () const
+{
+ return myUpperLimitYaw;
+}
+
+//=======================================================================
+//function : SetUpperLimitYaw
+//purpose :
+//=======================================================================
+void StepKinematics_PointOnPlanarCurvePairWithRange::SetUpperLimitYaw (const Standard_Real theUpperLimitYaw)
+{
+ myUpperLimitYaw = theUpperLimitYaw;
+}
+
+//=======================================================================
+//function : HasUpperLimitYaw
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_PointOnPlanarCurvePairWithRange::HasUpperLimitYaw () const
+{
+ return defUpperLimitYaw;
+}
+
+//=======================================================================
+//function : LowerLimitPitch
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_PointOnPlanarCurvePairWithRange::LowerLimitPitch () const
+{
+ return myLowerLimitPitch;
+}
+
+//=======================================================================
+//function : SetLowerLimitPitch
+//purpose :
+//=======================================================================
+void StepKinematics_PointOnPlanarCurvePairWithRange::SetLowerLimitPitch (const Standard_Real theLowerLimitPitch)
+{
+ myLowerLimitPitch = theLowerLimitPitch;
+}
+
+//=======================================================================
+//function : HasLowerLimitPitch
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_PointOnPlanarCurvePairWithRange::HasLowerLimitPitch () const
+{
+ return defLowerLimitPitch;
+}
+
+//=======================================================================
+//function : UpperLimitPitch
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_PointOnPlanarCurvePairWithRange::UpperLimitPitch () const
+{
+ return myUpperLimitPitch;
+}
+
+//=======================================================================
+//function : SetUpperLimitPitch
+//purpose :
+//=======================================================================
+void StepKinematics_PointOnPlanarCurvePairWithRange::SetUpperLimitPitch (const Standard_Real theUpperLimitPitch)
+{
+ myUpperLimitPitch = theUpperLimitPitch;
+}
+
+//=======================================================================
+//function : HasUpperLimitPitch
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_PointOnPlanarCurvePairWithRange::HasUpperLimitPitch () const
+{
+ return defUpperLimitPitch;
+}
+
+//=======================================================================
+//function : LowerLimitRoll
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_PointOnPlanarCurvePairWithRange::LowerLimitRoll () const
+{
+ return myLowerLimitRoll;
+}
+
+//=======================================================================
+//function : SetLowerLimitRoll
+//purpose :
+//=======================================================================
+void StepKinematics_PointOnPlanarCurvePairWithRange::SetLowerLimitRoll (const Standard_Real theLowerLimitRoll)
+{
+ myLowerLimitRoll = theLowerLimitRoll;
+}
+
+//=======================================================================
+//function : HasLowerLimitRoll
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_PointOnPlanarCurvePairWithRange::HasLowerLimitRoll () const
+{
+ return defLowerLimitRoll;
+}
+
+//=======================================================================
+//function : UpperLimitRoll
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_PointOnPlanarCurvePairWithRange::UpperLimitRoll () const
+{
+ return myUpperLimitRoll;
+}
+
+//=======================================================================
+//function : SetUpperLimitRoll
+//purpose :
+//=======================================================================
+void StepKinematics_PointOnPlanarCurvePairWithRange::SetUpperLimitRoll (const Standard_Real theUpperLimitRoll)
+{
+ myUpperLimitRoll = theUpperLimitRoll;
+}
+
+//=======================================================================
+//function : HasUpperLimitRoll
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_PointOnPlanarCurvePairWithRange::HasUpperLimitRoll () const
+{
+ return defUpperLimitRoll;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_PointOnPlanarCurvePairWithRange_HeaderFile_
+#define _StepKinematics_PointOnPlanarCurvePairWithRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_PointOnPlanarCurvePair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Curve.hxx>
+#include <StepGeom_TrimmedCurve.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_PointOnPlanarCurvePairWithRange, StepKinematics_PointOnPlanarCurvePair)
+
+//! Representation of STEP entity PointOnPlanarCurvePairWithRange
+class StepKinematics_PointOnPlanarCurvePairWithRange : public StepKinematics_PointOnPlanarCurvePair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_PointOnPlanarCurvePairWithRange();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Handle(StepGeom_Curve)& thePointOnPlanarCurvePair_PairCurve,
+ const Standard_Boolean thePointOnPlanarCurvePair_Orientation,
+ const Handle(StepGeom_TrimmedCurve)& theRangeOnPairCurve,
+ const Standard_Boolean hasLowerLimitYaw,
+ const Standard_Real theLowerLimitYaw,
+ const Standard_Boolean hasUpperLimitYaw,
+ const Standard_Real theUpperLimitYaw,
+ const Standard_Boolean hasLowerLimitPitch,
+ const Standard_Real theLowerLimitPitch,
+ const Standard_Boolean hasUpperLimitPitch,
+ const Standard_Real theUpperLimitPitch,
+ const Standard_Boolean hasLowerLimitRoll,
+ const Standard_Real theLowerLimitRoll,
+ const Standard_Boolean hasUpperLimitRoll,
+ const Standard_Real theUpperLimitRoll);
+
+ //! Returns field RangeOnPairCurve
+ Standard_EXPORT Handle(StepGeom_TrimmedCurve) RangeOnPairCurve() const;
+ //! Sets field RangeOnPairCurve
+ Standard_EXPORT void SetRangeOnPairCurve (const Handle(StepGeom_TrimmedCurve)& theRangeOnPairCurve);
+
+ //! Returns field LowerLimitYaw
+ Standard_EXPORT Standard_Real LowerLimitYaw() const;
+ //! Sets field LowerLimitYaw
+ Standard_EXPORT void SetLowerLimitYaw (const Standard_Real theLowerLimitYaw);
+ //! Returns True if optional field LowerLimitYaw is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitYaw() const;
+
+ //! Returns field UpperLimitYaw
+ Standard_EXPORT Standard_Real UpperLimitYaw() const;
+ //! Sets field UpperLimitYaw
+ Standard_EXPORT void SetUpperLimitYaw (const Standard_Real theUpperLimitYaw);
+ //! Returns True if optional field UpperLimitYaw is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitYaw() const;
+
+ //! Returns field LowerLimitPitch
+ Standard_EXPORT Standard_Real LowerLimitPitch() const;
+ //! Sets field LowerLimitPitch
+ Standard_EXPORT void SetLowerLimitPitch (const Standard_Real theLowerLimitPitch);
+ //! Returns True if optional field LowerLimitPitch is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitPitch() const;
+
+ //! Returns field UpperLimitPitch
+ Standard_EXPORT Standard_Real UpperLimitPitch() const;
+ //! Sets field UpperLimitPitch
+ Standard_EXPORT void SetUpperLimitPitch (const Standard_Real theUpperLimitPitch);
+ //! Returns True if optional field UpperLimitPitch is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitPitch() const;
+
+ //! Returns field LowerLimitRoll
+ Standard_EXPORT Standard_Real LowerLimitRoll() const;
+ //! Sets field LowerLimitRoll
+ Standard_EXPORT void SetLowerLimitRoll (const Standard_Real theLowerLimitRoll);
+ //! Returns True if optional field LowerLimitRoll is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitRoll() const;
+
+ //! Returns field UpperLimitRoll
+ Standard_EXPORT Standard_Real UpperLimitRoll() const;
+ //! Sets field UpperLimitRoll
+ Standard_EXPORT void SetUpperLimitRoll (const Standard_Real theUpperLimitRoll);
+ //! Returns True if optional field UpperLimitRoll is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitRoll() const;
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_PointOnPlanarCurvePairWithRange, StepKinematics_PointOnPlanarCurvePair)
+
+private:
+ Handle(StepGeom_TrimmedCurve) myRangeOnPairCurve;
+ Standard_Real myLowerLimitYaw; //!< optional
+ Standard_Real myUpperLimitYaw; //!< optional
+ Standard_Real myLowerLimitPitch; //!< optional
+ Standard_Real myUpperLimitPitch; //!< optional
+ Standard_Real myLowerLimitRoll; //!< optional
+ Standard_Real myUpperLimitRoll; //!< optional
+ Standard_Boolean defLowerLimitYaw; //!< flag "is LowerLimitYaw defined"
+ Standard_Boolean defUpperLimitYaw; //!< flag "is UpperLimitYaw defined"
+ Standard_Boolean defLowerLimitPitch; //!< flag "is LowerLimitPitch defined"
+ Standard_Boolean defUpperLimitPitch; //!< flag "is UpperLimitPitch defined"
+ Standard_Boolean defLowerLimitRoll; //!< flag "is LowerLimitRoll defined"
+ Standard_Boolean defUpperLimitRoll; //!< flag "is UpperLimitRoll defined"
+
+};
+#endif // _StepKinematics_PointOnPlanarCurvePairWithRange_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_PointOnSurfacePair.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_PointOnSurfacePair, StepKinematics_HighOrderKinematicPair)
+
+//=======================================================================
+//function : StepKinematics_PointOnSurfacePair
+//purpose :
+//=======================================================================
+StepKinematics_PointOnSurfacePair::StepKinematics_PointOnSurfacePair ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_PointOnSurfacePair::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Handle(StepGeom_Surface)& thePairSurface)
+{
+ StepKinematics_HighOrderKinematicPair::Init(theRepresentationItem_Name,
+ theItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2,
+ theKinematicPair_Joint);
+
+ myPairSurface = thePairSurface;
+}
+
+//=======================================================================
+//function : PairSurface
+//purpose :
+//=======================================================================
+Handle(StepGeom_Surface) StepKinematics_PointOnSurfacePair::PairSurface () const
+{
+ return myPairSurface;
+}
+
+//=======================================================================
+//function : SetPairSurface
+//purpose :
+//=======================================================================
+void StepKinematics_PointOnSurfacePair::SetPairSurface (const Handle(StepGeom_Surface)& thePairSurface)
+{
+ myPairSurface = thePairSurface;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_PointOnSurfacePair_HeaderFile_
+#define _StepKinematics_PointOnSurfacePair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_HighOrderKinematicPair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Surface.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_PointOnSurfacePair, StepKinematics_HighOrderKinematicPair)
+
+//! Representation of STEP entity PointOnSurfacePair
+class StepKinematics_PointOnSurfacePair : public StepKinematics_HighOrderKinematicPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_PointOnSurfacePair();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Handle(StepGeom_Surface)& thePairSurface);
+
+ //! Returns field PairSurface
+ Standard_EXPORT Handle(StepGeom_Surface) PairSurface() const;
+ //! Sets field PairSurface
+ Standard_EXPORT void SetPairSurface (const Handle(StepGeom_Surface)& thePairSurface);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_PointOnSurfacePair, StepKinematics_HighOrderKinematicPair)
+
+private:
+ Handle(StepGeom_Surface) myPairSurface;
+
+};
+#endif // _StepKinematics_PointOnSurfacePair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_PointOnSurfacePairValue.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_PointOnSurfacePairValue, StepKinematics_PairValue)
+
+//=======================================================================
+//function : StepKinematics_PointOnSurfacePairValue
+//purpose :
+//=======================================================================
+StepKinematics_PointOnSurfacePairValue::StepKinematics_PointOnSurfacePairValue ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_PointOnSurfacePairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface,
+ const StepKinematics_SpatialRotation& theInputOrientation)
+{
+ StepKinematics_PairValue::Init(theRepresentationItem_Name,
+ thePairValue_AppliesToPair);
+
+ myActualPointOnSurface = theActualPointOnSurface;
+
+ myInputOrientation = theInputOrientation;
+}
+
+//=======================================================================
+//function : ActualPointOnSurface
+//purpose :
+//=======================================================================
+Handle(StepGeom_PointOnSurface) StepKinematics_PointOnSurfacePairValue::ActualPointOnSurface () const
+{
+ return myActualPointOnSurface;
+}
+
+//=======================================================================
+//function : SetActualPointOnSurface
+//purpose :
+//=======================================================================
+void StepKinematics_PointOnSurfacePairValue::SetActualPointOnSurface (const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface)
+{
+ myActualPointOnSurface = theActualPointOnSurface;
+}
+
+//=======================================================================
+//function : InputOrientation
+//purpose :
+//=======================================================================
+StepKinematics_SpatialRotation StepKinematics_PointOnSurfacePairValue::InputOrientation () const
+{
+ return myInputOrientation;
+}
+
+//=======================================================================
+//function : SetInputOrientation
+//purpose :
+//=======================================================================
+void StepKinematics_PointOnSurfacePairValue::SetInputOrientation (const StepKinematics_SpatialRotation& theInputOrientation)
+{
+ myInputOrientation = theInputOrientation;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_PointOnSurfacePairValue_HeaderFile_
+#define _StepKinematics_PointOnSurfacePairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_PairValue.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <StepGeom_PointOnSurface.hxx>
+#include <StepKinematics_SpatialRotation.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_PointOnSurfacePairValue, StepKinematics_PairValue)
+
+//! Representation of STEP entity PointOnSurfacePairValue
+class StepKinematics_PointOnSurfacePairValue : public StepKinematics_PairValue
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_PointOnSurfacePairValue();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface,
+ const StepKinematics_SpatialRotation& theInputOrientation);
+
+ //! Returns field ActualPointOnSurface
+ Standard_EXPORT Handle(StepGeom_PointOnSurface) ActualPointOnSurface() const;
+ //! Sets field ActualPointOnSurface
+ Standard_EXPORT void SetActualPointOnSurface (const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface);
+
+ //! Returns field InputOrientation
+ Standard_EXPORT StepKinematics_SpatialRotation InputOrientation() const;
+ //! Sets field InputOrientation
+ Standard_EXPORT void SetInputOrientation (const StepKinematics_SpatialRotation& theInputOrientation);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_PointOnSurfacePairValue, StepKinematics_PairValue)
+
+private:
+ Handle(StepGeom_PointOnSurface) myActualPointOnSurface;
+ StepKinematics_SpatialRotation myInputOrientation;
+
+};
+#endif // _StepKinematics_PointOnSurfacePairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_PointOnSurfacePairWithRange.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_PointOnSurfacePairWithRange, StepKinematics_PointOnSurfacePair)
+
+//=======================================================================
+//function : StepKinematics_PointOnSurfacePairWithRange
+//purpose :
+//=======================================================================
+StepKinematics_PointOnSurfacePairWithRange::StepKinematics_PointOnSurfacePairWithRange ()
+{
+ defLowerLimitYaw = Standard_False;
+ defUpperLimitYaw = Standard_False;
+ defLowerLimitPitch = Standard_False;
+ defUpperLimitPitch = Standard_False;
+ defLowerLimitRoll = Standard_False;
+ defUpperLimitRoll = Standard_False;
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_PointOnSurfacePairWithRange::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Handle(StepGeom_Surface)& thePointOnSurfacePair_PairSurface,
+ const Handle(StepGeom_RectangularTrimmedSurface)& theRangeOnPairSurface,
+ const Standard_Boolean hasLowerLimitYaw,
+ const Standard_Real theLowerLimitYaw,
+ const Standard_Boolean hasUpperLimitYaw,
+ const Standard_Real theUpperLimitYaw,
+ const Standard_Boolean hasLowerLimitPitch,
+ const Standard_Real theLowerLimitPitch,
+ const Standard_Boolean hasUpperLimitPitch,
+ const Standard_Real theUpperLimitPitch,
+ const Standard_Boolean hasLowerLimitRoll,
+ const Standard_Real theLowerLimitRoll,
+ const Standard_Boolean hasUpperLimitRoll,
+ const Standard_Real theUpperLimitRoll)
+{
+ StepKinematics_PointOnSurfacePair::Init(theRepresentationItem_Name,
+ theItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2,
+ theKinematicPair_Joint,
+ thePointOnSurfacePair_PairSurface);
+
+ myRangeOnPairSurface = theRangeOnPairSurface;
+
+ defLowerLimitYaw = hasLowerLimitYaw;
+ if (defLowerLimitYaw) {
+ myLowerLimitYaw = theLowerLimitYaw;
+ }
+ else myLowerLimitYaw = 0;
+
+ defUpperLimitYaw = hasUpperLimitYaw;
+ if (defUpperLimitYaw) {
+ myUpperLimitYaw = theUpperLimitYaw;
+ }
+ else myUpperLimitYaw = 0;
+
+ defLowerLimitPitch = hasLowerLimitPitch;
+ if (defLowerLimitPitch) {
+ myLowerLimitPitch = theLowerLimitPitch;
+ }
+ else myLowerLimitPitch = 0;
+
+ defUpperLimitPitch = hasUpperLimitPitch;
+ if (defUpperLimitPitch) {
+ myUpperLimitPitch = theUpperLimitPitch;
+ }
+ else myUpperLimitPitch = 0;
+
+ defLowerLimitRoll = hasLowerLimitRoll;
+ if (defLowerLimitRoll) {
+ myLowerLimitRoll = theLowerLimitRoll;
+ }
+ else myLowerLimitRoll = 0;
+
+ defUpperLimitRoll = hasUpperLimitRoll;
+ if (defUpperLimitRoll) {
+ myUpperLimitRoll = theUpperLimitRoll;
+ }
+ else myUpperLimitRoll = 0;
+}
+
+//=======================================================================
+//function : RangeOnPairSurface
+//purpose :
+//=======================================================================
+Handle(StepGeom_RectangularTrimmedSurface) StepKinematics_PointOnSurfacePairWithRange::RangeOnPairSurface () const
+{
+ return myRangeOnPairSurface;
+}
+
+//=======================================================================
+//function : SetRangeOnPairSurface
+//purpose :
+//=======================================================================
+void StepKinematics_PointOnSurfacePairWithRange::SetRangeOnPairSurface (const Handle(StepGeom_RectangularTrimmedSurface)& theRangeOnPairSurface)
+{
+ myRangeOnPairSurface = theRangeOnPairSurface;
+}
+
+//=======================================================================
+//function : LowerLimitYaw
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_PointOnSurfacePairWithRange::LowerLimitYaw () const
+{
+ return myLowerLimitYaw;
+}
+
+//=======================================================================
+//function : SetLowerLimitYaw
+//purpose :
+//=======================================================================
+void StepKinematics_PointOnSurfacePairWithRange::SetLowerLimitYaw (const Standard_Real theLowerLimitYaw)
+{
+ myLowerLimitYaw = theLowerLimitYaw;
+}
+
+//=======================================================================
+//function : HasLowerLimitYaw
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_PointOnSurfacePairWithRange::HasLowerLimitYaw () const
+{
+ return defLowerLimitYaw;
+}
+
+//=======================================================================
+//function : UpperLimitYaw
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_PointOnSurfacePairWithRange::UpperLimitYaw () const
+{
+ return myUpperLimitYaw;
+}
+
+//=======================================================================
+//function : SetUpperLimitYaw
+//purpose :
+//=======================================================================
+void StepKinematics_PointOnSurfacePairWithRange::SetUpperLimitYaw (const Standard_Real theUpperLimitYaw)
+{
+ myUpperLimitYaw = theUpperLimitYaw;
+}
+
+//=======================================================================
+//function : HasUpperLimitYaw
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_PointOnSurfacePairWithRange::HasUpperLimitYaw () const
+{
+ return defUpperLimitYaw;
+}
+
+//=======================================================================
+//function : LowerLimitPitch
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_PointOnSurfacePairWithRange::LowerLimitPitch () const
+{
+ return myLowerLimitPitch;
+}
+
+//=======================================================================
+//function : SetLowerLimitPitch
+//purpose :
+//=======================================================================
+void StepKinematics_PointOnSurfacePairWithRange::SetLowerLimitPitch (const Standard_Real theLowerLimitPitch)
+{
+ myLowerLimitPitch = theLowerLimitPitch;
+}
+
+//=======================================================================
+//function : HasLowerLimitPitch
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_PointOnSurfacePairWithRange::HasLowerLimitPitch () const
+{
+ return defLowerLimitPitch;
+}
+
+//=======================================================================
+//function : UpperLimitPitch
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_PointOnSurfacePairWithRange::UpperLimitPitch () const
+{
+ return myUpperLimitPitch;
+}
+
+//=======================================================================
+//function : SetUpperLimitPitch
+//purpose :
+//=======================================================================
+void StepKinematics_PointOnSurfacePairWithRange::SetUpperLimitPitch (const Standard_Real theUpperLimitPitch)
+{
+ myUpperLimitPitch = theUpperLimitPitch;
+}
+
+//=======================================================================
+//function : HasUpperLimitPitch
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_PointOnSurfacePairWithRange::HasUpperLimitPitch () const
+{
+ return defUpperLimitPitch;
+}
+
+//=======================================================================
+//function : LowerLimitRoll
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_PointOnSurfacePairWithRange::LowerLimitRoll () const
+{
+ return myLowerLimitRoll;
+}
+
+//=======================================================================
+//function : SetLowerLimitRoll
+//purpose :
+//=======================================================================
+void StepKinematics_PointOnSurfacePairWithRange::SetLowerLimitRoll (const Standard_Real theLowerLimitRoll)
+{
+ myLowerLimitRoll = theLowerLimitRoll;
+}
+
+//=======================================================================
+//function : HasLowerLimitRoll
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_PointOnSurfacePairWithRange::HasLowerLimitRoll () const
+{
+ return defLowerLimitRoll;
+}
+
+//=======================================================================
+//function : UpperLimitRoll
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_PointOnSurfacePairWithRange::UpperLimitRoll () const
+{
+ return myUpperLimitRoll;
+}
+
+//=======================================================================
+//function : SetUpperLimitRoll
+//purpose :
+//=======================================================================
+void StepKinematics_PointOnSurfacePairWithRange::SetUpperLimitRoll (const Standard_Real theUpperLimitRoll)
+{
+ myUpperLimitRoll = theUpperLimitRoll;
+}
+
+//=======================================================================
+//function : HasUpperLimitRoll
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_PointOnSurfacePairWithRange::HasUpperLimitRoll () const
+{
+ return defUpperLimitRoll;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_PointOnSurfacePairWithRange_HeaderFile_
+#define _StepKinematics_PointOnSurfacePairWithRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_PointOnSurfacePair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Surface.hxx>
+#include <StepGeom_RectangularTrimmedSurface.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_PointOnSurfacePairWithRange, StepKinematics_PointOnSurfacePair)
+
+//! Representation of STEP entity PointOnSurfacePairWithRange
+class StepKinematics_PointOnSurfacePairWithRange : public StepKinematics_PointOnSurfacePair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_PointOnSurfacePairWithRange();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Handle(StepGeom_Surface)& thePointOnSurfacePair_PairSurface,
+ const Handle(StepGeom_RectangularTrimmedSurface)& theRangeOnPairSurface,
+ const Standard_Boolean hasLowerLimitYaw,
+ const Standard_Real theLowerLimitYaw,
+ const Standard_Boolean hasUpperLimitYaw,
+ const Standard_Real theUpperLimitYaw,
+ const Standard_Boolean hasLowerLimitPitch,
+ const Standard_Real theLowerLimitPitch,
+ const Standard_Boolean hasUpperLimitPitch,
+ const Standard_Real theUpperLimitPitch,
+ const Standard_Boolean hasLowerLimitRoll,
+ const Standard_Real theLowerLimitRoll,
+ const Standard_Boolean hasUpperLimitRoll,
+ const Standard_Real theUpperLimitRoll);
+
+ //! Returns field RangeOnPairSurface
+ Standard_EXPORT Handle(StepGeom_RectangularTrimmedSurface) RangeOnPairSurface() const;
+ //! Sets field RangeOnPairSurface
+ Standard_EXPORT void SetRangeOnPairSurface (const Handle(StepGeom_RectangularTrimmedSurface)& theRangeOnPairSurface);
+
+ //! Returns field LowerLimitYaw
+ Standard_EXPORT Standard_Real LowerLimitYaw() const;
+ //! Sets field LowerLimitYaw
+ Standard_EXPORT void SetLowerLimitYaw (const Standard_Real theLowerLimitYaw);
+ //! Returns True if optional field LowerLimitYaw is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitYaw() const;
+
+ //! Returns field UpperLimitYaw
+ Standard_EXPORT Standard_Real UpperLimitYaw() const;
+ //! Sets field UpperLimitYaw
+ Standard_EXPORT void SetUpperLimitYaw (const Standard_Real theUpperLimitYaw);
+ //! Returns True if optional field UpperLimitYaw is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitYaw() const;
+
+ //! Returns field LowerLimitPitch
+ Standard_EXPORT Standard_Real LowerLimitPitch() const;
+ //! Sets field LowerLimitPitch
+ Standard_EXPORT void SetLowerLimitPitch (const Standard_Real theLowerLimitPitch);
+ //! Returns True if optional field LowerLimitPitch is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitPitch() const;
+
+ //! Returns field UpperLimitPitch
+ Standard_EXPORT Standard_Real UpperLimitPitch() const;
+ //! Sets field UpperLimitPitch
+ Standard_EXPORT void SetUpperLimitPitch (const Standard_Real theUpperLimitPitch);
+ //! Returns True if optional field UpperLimitPitch is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitPitch() const;
+
+ //! Returns field LowerLimitRoll
+ Standard_EXPORT Standard_Real LowerLimitRoll() const;
+ //! Sets field LowerLimitRoll
+ Standard_EXPORT void SetLowerLimitRoll (const Standard_Real theLowerLimitRoll);
+ //! Returns True if optional field LowerLimitRoll is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitRoll() const;
+
+ //! Returns field UpperLimitRoll
+ Standard_EXPORT Standard_Real UpperLimitRoll() const;
+ //! Sets field UpperLimitRoll
+ Standard_EXPORT void SetUpperLimitRoll (const Standard_Real theUpperLimitRoll);
+ //! Returns True if optional field UpperLimitRoll is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitRoll() const;
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_PointOnSurfacePairWithRange, StepKinematics_PointOnSurfacePair)
+
+private:
+ Handle(StepGeom_RectangularTrimmedSurface) myRangeOnPairSurface;
+ Standard_Real myLowerLimitYaw; //!< optional
+ Standard_Real myUpperLimitYaw; //!< optional
+ Standard_Real myLowerLimitPitch; //!< optional
+ Standard_Real myUpperLimitPitch; //!< optional
+ Standard_Real myLowerLimitRoll; //!< optional
+ Standard_Real myUpperLimitRoll; //!< optional
+ Standard_Boolean defLowerLimitYaw; //!< flag "is LowerLimitYaw defined"
+ Standard_Boolean defUpperLimitYaw; //!< flag "is UpperLimitYaw defined"
+ Standard_Boolean defLowerLimitPitch; //!< flag "is LowerLimitPitch defined"
+ Standard_Boolean defUpperLimitPitch; //!< flag "is UpperLimitPitch defined"
+ Standard_Boolean defLowerLimitRoll; //!< flag "is LowerLimitRoll defined"
+ Standard_Boolean defUpperLimitRoll; //!< flag "is UpperLimitRoll defined"
+
+};
+#endif // _StepKinematics_PointOnSurfacePairWithRange_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_PrismaticPair.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_PrismaticPair, StepKinematics_LowOrderKinematicPair)
+
+//=======================================================================
+//function : StepKinematics_PrismaticPair
+//purpose :
+//=======================================================================
+StepKinematics_PrismaticPair::StepKinematics_PrismaticPair ()
+{
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_PrismaticPair_HeaderFile_
+#define _StepKinematics_PrismaticPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_LowOrderKinematicPair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_PrismaticPair, StepKinematics_LowOrderKinematicPair)
+
+//! Representation of STEP entity PrismaticPair
+class StepKinematics_PrismaticPair : public StepKinematics_LowOrderKinematicPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_PrismaticPair();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_PrismaticPair, StepKinematics_LowOrderKinematicPair)
+
+};
+#endif // _StepKinematics_PrismaticPair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_PrismaticPairValue.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_PrismaticPairValue, StepKinematics_PairValue)
+
+//=======================================================================
+//function : StepKinematics_PrismaticPairValue
+//purpose :
+//=======================================================================
+StepKinematics_PrismaticPairValue::StepKinematics_PrismaticPairValue ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_PrismaticPairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Standard_Real theActualTranslation)
+{
+ StepKinematics_PairValue::Init(theRepresentationItem_Name,
+ thePairValue_AppliesToPair);
+
+ myActualTranslation = theActualTranslation;
+}
+
+//=======================================================================
+//function : ActualTranslation
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_PrismaticPairValue::ActualTranslation () const
+{
+ return myActualTranslation;
+}
+
+//=======================================================================
+//function : SetActualTranslation
+//purpose :
+//=======================================================================
+void StepKinematics_PrismaticPairValue::SetActualTranslation (const Standard_Real theActualTranslation)
+{
+ myActualTranslation = theActualTranslation;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_PrismaticPairValue_HeaderFile_
+#define _StepKinematics_PrismaticPairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_PairValue.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_PrismaticPairValue, StepKinematics_PairValue)
+
+//! Representation of STEP entity PrismaticPairValue
+class StepKinematics_PrismaticPairValue : public StepKinematics_PairValue
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_PrismaticPairValue();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Standard_Real theActualTranslation);
+
+ //! Returns field ActualTranslation
+ Standard_EXPORT Standard_Real ActualTranslation() const;
+ //! Sets field ActualTranslation
+ Standard_EXPORT void SetActualTranslation (const Standard_Real theActualTranslation);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_PrismaticPairValue, StepKinematics_PairValue)
+
+private:
+ Standard_Real myActualTranslation;
+
+};
+#endif // _StepKinematics_PrismaticPairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_PrismaticPairWithRange.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_PrismaticPairWithRange, StepKinematics_PrismaticPair)
+
+//=======================================================================
+//function : StepKinematics_PrismaticPairWithRange
+//purpose :
+//=======================================================================
+StepKinematics_PrismaticPairWithRange::StepKinematics_PrismaticPairWithRange ()
+{
+ defLowerLimitActualTranslation = Standard_False;
+ defUpperLimitActualTranslation = Standard_False;
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_PrismaticPairWithRange::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Boolean theLowOrderKinematicPair_TX,
+ const Standard_Boolean theLowOrderKinematicPair_TY,
+ const Standard_Boolean theLowOrderKinematicPair_TZ,
+ const Standard_Boolean theLowOrderKinematicPair_RX,
+ const Standard_Boolean theLowOrderKinematicPair_RY,
+ const Standard_Boolean theLowOrderKinematicPair_RZ,
+ const Standard_Boolean hasLowerLimitActualTranslation,
+ const Standard_Real theLowerLimitActualTranslation,
+ const Standard_Boolean hasUpperLimitActualTranslation,
+ const Standard_Real theUpperLimitActualTranslation)
+{
+ StepKinematics_PrismaticPair::Init(theRepresentationItem_Name,
+ theItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2,
+ theKinematicPair_Joint,
+ theLowOrderKinematicPair_TX,
+ theLowOrderKinematicPair_TY,
+ theLowOrderKinematicPair_TZ,
+ theLowOrderKinematicPair_RX,
+ theLowOrderKinematicPair_RY,
+ theLowOrderKinematicPair_RZ);
+
+ defLowerLimitActualTranslation = hasLowerLimitActualTranslation;
+ if (defLowerLimitActualTranslation) {
+ myLowerLimitActualTranslation = theLowerLimitActualTranslation;
+ }
+ else myLowerLimitActualTranslation = 0;
+
+ defUpperLimitActualTranslation = hasUpperLimitActualTranslation;
+ if (defUpperLimitActualTranslation) {
+ myUpperLimitActualTranslation = theUpperLimitActualTranslation;
+ }
+ else myUpperLimitActualTranslation = 0;
+}
+
+//=======================================================================
+//function : LowerLimitActualTranslation
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_PrismaticPairWithRange::LowerLimitActualTranslation () const
+{
+ return myLowerLimitActualTranslation;
+}
+
+//=======================================================================
+//function : SetLowerLimitActualTranslation
+//purpose :
+//=======================================================================
+void StepKinematics_PrismaticPairWithRange::SetLowerLimitActualTranslation (const Standard_Real theLowerLimitActualTranslation)
+{
+ myLowerLimitActualTranslation = theLowerLimitActualTranslation;
+}
+
+//=======================================================================
+//function : HasLowerLimitActualTranslation
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_PrismaticPairWithRange::HasLowerLimitActualTranslation () const
+{
+ return defLowerLimitActualTranslation;
+}
+
+//=======================================================================
+//function : UpperLimitActualTranslation
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_PrismaticPairWithRange::UpperLimitActualTranslation () const
+{
+ return myUpperLimitActualTranslation;
+}
+
+//=======================================================================
+//function : SetUpperLimitActualTranslation
+//purpose :
+//=======================================================================
+void StepKinematics_PrismaticPairWithRange::SetUpperLimitActualTranslation (const Standard_Real theUpperLimitActualTranslation)
+{
+ myUpperLimitActualTranslation = theUpperLimitActualTranslation;
+}
+
+//=======================================================================
+//function : HasUpperLimitActualTranslation
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_PrismaticPairWithRange::HasUpperLimitActualTranslation () const
+{
+ return defUpperLimitActualTranslation;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_PrismaticPairWithRange_HeaderFile_
+#define _StepKinematics_PrismaticPairWithRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_PrismaticPair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_PrismaticPairWithRange, StepKinematics_PrismaticPair)
+
+//! Representation of STEP entity PrismaticPairWithRange
+class StepKinematics_PrismaticPairWithRange : public StepKinematics_PrismaticPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_PrismaticPairWithRange();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Boolean theLowOrderKinematicPair_TX,
+ const Standard_Boolean theLowOrderKinematicPair_TY,
+ const Standard_Boolean theLowOrderKinematicPair_TZ,
+ const Standard_Boolean theLowOrderKinematicPair_RX,
+ const Standard_Boolean theLowOrderKinematicPair_RY,
+ const Standard_Boolean theLowOrderKinematicPair_RZ,
+ const Standard_Boolean hasLowerLimitActualTranslation,
+ const Standard_Real theLowerLimitActualTranslation,
+ const Standard_Boolean hasUpperLimitActualTranslation,
+ const Standard_Real theUpperLimitActualTranslation);
+
+ //! Returns field LowerLimitActualTranslation
+ Standard_EXPORT Standard_Real LowerLimitActualTranslation() const;
+ //! Sets field LowerLimitActualTranslation
+ Standard_EXPORT void SetLowerLimitActualTranslation (const Standard_Real theLowerLimitActualTranslation);
+ //! Returns True if optional field LowerLimitActualTranslation is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitActualTranslation() const;
+
+ //! Returns field UpperLimitActualTranslation
+ Standard_EXPORT Standard_Real UpperLimitActualTranslation() const;
+ //! Sets field UpperLimitActualTranslation
+ Standard_EXPORT void SetUpperLimitActualTranslation (const Standard_Real theUpperLimitActualTranslation);
+ //! Returns True if optional field UpperLimitActualTranslation is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitActualTranslation() const;
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_PrismaticPairWithRange, StepKinematics_PrismaticPair)
+
+private:
+ Standard_Real myLowerLimitActualTranslation; //!< optional
+ Standard_Real myUpperLimitActualTranslation; //!< optional
+ Standard_Boolean defLowerLimitActualTranslation; //!< flag "is LowerLimitActualTranslation defined"
+ Standard_Boolean defUpperLimitActualTranslation; //!< flag "is UpperLimitActualTranslation defined"
+
+};
+#endif // _StepKinematics_PrismaticPairWithRange_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_ProductDefinitionKinematics.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_ProductDefinitionKinematics, StepRepr_PropertyDefinition)
+
+//=======================================================================
+//function : StepKinematics_ProductDefinitionKinematics
+//purpose :
+//=======================================================================
+StepKinematics_ProductDefinitionKinematics::StepKinematics_ProductDefinitionKinematics ()
+{
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_ProductDefinitionKinematics_HeaderFile_
+#define _StepKinematics_ProductDefinitionKinematics_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepRepr_PropertyDefinition.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_CharacterizedDefinition.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_ProductDefinitionKinematics, StepRepr_PropertyDefinition)
+
+//! Representation of STEP entity ProductDefinitionKinematics
+class StepKinematics_ProductDefinitionKinematics : public StepRepr_PropertyDefinition
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_ProductDefinitionKinematics();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_ProductDefinitionKinematics, StepRepr_PropertyDefinition)
+
+};
+#endif // _StepKinematics_ProductDefinitionKinematics_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_ProductDefinitionRelationshipKinematics.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_ProductDefinitionRelationshipKinematics, StepRepr_PropertyDefinition)
+
+//=======================================================================
+//function : StepKinematics_ProductDefinitionRelationshipKinematics
+//purpose :
+//=======================================================================
+StepKinematics_ProductDefinitionRelationshipKinematics::StepKinematics_ProductDefinitionRelationshipKinematics ()
+{
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_ProductDefinitionRelationshipKinematics_HeaderFile_
+#define _StepKinematics_ProductDefinitionRelationshipKinematics_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepRepr_PropertyDefinition.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_CharacterizedDefinition.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_ProductDefinitionRelationshipKinematics, StepRepr_PropertyDefinition)
+
+//! Representation of STEP entity ProductDefinitionRelationshipKinematics
+class StepKinematics_ProductDefinitionRelationshipKinematics : public StepRepr_PropertyDefinition
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_ProductDefinitionRelationshipKinematics();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_ProductDefinitionRelationshipKinematics, StepRepr_PropertyDefinition)
+
+};
+#endif // _StepKinematics_ProductDefinitionRelationshipKinematics_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_RackAndPinionPair.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_RackAndPinionPair, StepKinematics_LowOrderKinematicPairWithMotionCoupling)
+
+//=======================================================================
+//function : StepKinematics_RackAndPinionPair
+//purpose :
+//=======================================================================
+StepKinematics_RackAndPinionPair::StepKinematics_RackAndPinionPair ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_RackAndPinionPair::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Real thePinionRadius)
+{
+ StepKinematics_LowOrderKinematicPairWithMotionCoupling::Init(theRepresentationItem_Name,
+ theItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2,
+ theKinematicPair_Joint);
+
+ myPinionRadius = thePinionRadius;
+}
+
+//=======================================================================
+//function : PinionRadius
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_RackAndPinionPair::PinionRadius () const
+{
+ return myPinionRadius;
+}
+
+//=======================================================================
+//function : SetPinionRadius
+//purpose :
+//=======================================================================
+void StepKinematics_RackAndPinionPair::SetPinionRadius (const Standard_Real thePinionRadius)
+{
+ myPinionRadius = thePinionRadius;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_RackAndPinionPair_HeaderFile_
+#define _StepKinematics_RackAndPinionPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_LowOrderKinematicPairWithMotionCoupling.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_RackAndPinionPair, StepKinematics_LowOrderKinematicPairWithMotionCoupling)
+
+//! Representation of STEP entity RackAndPinionPair
+class StepKinematics_RackAndPinionPair : public StepKinematics_LowOrderKinematicPairWithMotionCoupling
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_RackAndPinionPair();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Real thePinionRadius);
+
+ //! Returns field PinionRadius
+ Standard_EXPORT Standard_Real PinionRadius() const;
+ //! Sets field PinionRadius
+ Standard_EXPORT void SetPinionRadius (const Standard_Real thePinionRadius);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_RackAndPinionPair, StepKinematics_LowOrderKinematicPairWithMotionCoupling)
+
+private:
+ Standard_Real myPinionRadius;
+
+};
+#endif // _StepKinematics_RackAndPinionPair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_RackAndPinionPairValue.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_RackAndPinionPairValue, StepKinematics_PairValue)
+
+//=======================================================================
+//function : StepKinematics_RackAndPinionPairValue
+//purpose :
+//=======================================================================
+StepKinematics_RackAndPinionPairValue::StepKinematics_RackAndPinionPairValue ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_RackAndPinionPairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Standard_Real theActualDisplacement)
+{
+ StepKinematics_PairValue::Init(theRepresentationItem_Name,
+ thePairValue_AppliesToPair);
+
+ myActualDisplacement = theActualDisplacement;
+}
+
+//=======================================================================
+//function : ActualDisplacement
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_RackAndPinionPairValue::ActualDisplacement () const
+{
+ return myActualDisplacement;
+}
+
+//=======================================================================
+//function : SetActualDisplacement
+//purpose :
+//=======================================================================
+void StepKinematics_RackAndPinionPairValue::SetActualDisplacement (const Standard_Real theActualDisplacement)
+{
+ myActualDisplacement = theActualDisplacement;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_RackAndPinionPairValue_HeaderFile_
+#define _StepKinematics_RackAndPinionPairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_PairValue.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_RackAndPinionPairValue, StepKinematics_PairValue)
+
+//! Representation of STEP entity RackAndPinionPairValue
+class StepKinematics_RackAndPinionPairValue : public StepKinematics_PairValue
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_RackAndPinionPairValue();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Standard_Real theActualDisplacement);
+
+ //! Returns field ActualDisplacement
+ Standard_EXPORT Standard_Real ActualDisplacement() const;
+ //! Sets field ActualDisplacement
+ Standard_EXPORT void SetActualDisplacement (const Standard_Real theActualDisplacement);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_RackAndPinionPairValue, StepKinematics_PairValue)
+
+private:
+ Standard_Real myActualDisplacement;
+
+};
+#endif // _StepKinematics_RackAndPinionPairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_RackAndPinionPairWithRange.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_RackAndPinionPairWithRange, StepKinematics_RackAndPinionPair)
+
+//=======================================================================
+//function : StepKinematics_RackAndPinionPairWithRange
+//purpose :
+//=======================================================================
+StepKinematics_RackAndPinionPairWithRange::StepKinematics_RackAndPinionPairWithRange ()
+{
+ defLowerLimitRackDisplacement = Standard_False;
+ defUpperLimitRackDisplacement = Standard_False;
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_RackAndPinionPairWithRange::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Real theRackAndPinionPair_PinionRadius,
+ const Standard_Boolean hasLowerLimitRackDisplacement,
+ const Standard_Real theLowerLimitRackDisplacement,
+ const Standard_Boolean hasUpperLimitRackDisplacement,
+ const Standard_Real theUpperLimitRackDisplacement)
+{
+ StepKinematics_RackAndPinionPair::Init(theRepresentationItem_Name,
+ theItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2,
+ theKinematicPair_Joint,
+ theRackAndPinionPair_PinionRadius);
+
+ defLowerLimitRackDisplacement = hasLowerLimitRackDisplacement;
+ if (defLowerLimitRackDisplacement) {
+ myLowerLimitRackDisplacement = theLowerLimitRackDisplacement;
+ }
+ else myLowerLimitRackDisplacement = 0;
+
+ defUpperLimitRackDisplacement = hasUpperLimitRackDisplacement;
+ if (defUpperLimitRackDisplacement) {
+ myUpperLimitRackDisplacement = theUpperLimitRackDisplacement;
+ }
+ else myUpperLimitRackDisplacement = 0;
+}
+
+//=======================================================================
+//function : LowerLimitRackDisplacement
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_RackAndPinionPairWithRange::LowerLimitRackDisplacement () const
+{
+ return myLowerLimitRackDisplacement;
+}
+
+//=======================================================================
+//function : SetLowerLimitRackDisplacement
+//purpose :
+//=======================================================================
+void StepKinematics_RackAndPinionPairWithRange::SetLowerLimitRackDisplacement (const Standard_Real theLowerLimitRackDisplacement)
+{
+ myLowerLimitRackDisplacement = theLowerLimitRackDisplacement;
+}
+
+//=======================================================================
+//function : HasLowerLimitRackDisplacement
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_RackAndPinionPairWithRange::HasLowerLimitRackDisplacement () const
+{
+ return defLowerLimitRackDisplacement;
+}
+
+//=======================================================================
+//function : UpperLimitRackDisplacement
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_RackAndPinionPairWithRange::UpperLimitRackDisplacement () const
+{
+ return myUpperLimitRackDisplacement;
+}
+
+//=======================================================================
+//function : SetUpperLimitRackDisplacement
+//purpose :
+//=======================================================================
+void StepKinematics_RackAndPinionPairWithRange::SetUpperLimitRackDisplacement (const Standard_Real theUpperLimitRackDisplacement)
+{
+ myUpperLimitRackDisplacement = theUpperLimitRackDisplacement;
+}
+
+//=======================================================================
+//function : HasUpperLimitRackDisplacement
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_RackAndPinionPairWithRange::HasUpperLimitRackDisplacement () const
+{
+ return defUpperLimitRackDisplacement;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_RackAndPinionPairWithRange_HeaderFile_
+#define _StepKinematics_RackAndPinionPairWithRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_RackAndPinionPair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_RackAndPinionPairWithRange, StepKinematics_RackAndPinionPair)
+
+//! Representation of STEP entity RackAndPinionPairWithRange
+class StepKinematics_RackAndPinionPairWithRange : public StepKinematics_RackAndPinionPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_RackAndPinionPairWithRange();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Real theRackAndPinionPair_PinionRadius,
+ const Standard_Boolean hasLowerLimitRackDisplacement,
+ const Standard_Real theLowerLimitRackDisplacement,
+ const Standard_Boolean hasUpperLimitRackDisplacement,
+ const Standard_Real theUpperLimitRackDisplacement);
+
+ //! Returns field LowerLimitRackDisplacement
+ Standard_EXPORT Standard_Real LowerLimitRackDisplacement() const;
+ //! Sets field LowerLimitRackDisplacement
+ Standard_EXPORT void SetLowerLimitRackDisplacement (const Standard_Real theLowerLimitRackDisplacement);
+ //! Returns True if optional field LowerLimitRackDisplacement is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitRackDisplacement() const;
+
+ //! Returns field UpperLimitRackDisplacement
+ Standard_EXPORT Standard_Real UpperLimitRackDisplacement() const;
+ //! Sets field UpperLimitRackDisplacement
+ Standard_EXPORT void SetUpperLimitRackDisplacement (const Standard_Real theUpperLimitRackDisplacement);
+ //! Returns True if optional field UpperLimitRackDisplacement is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitRackDisplacement() const;
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_RackAndPinionPairWithRange, StepKinematics_RackAndPinionPair)
+
+private:
+ Standard_Real myLowerLimitRackDisplacement; //!< optional
+ Standard_Real myUpperLimitRackDisplacement; //!< optional
+ Standard_Boolean defLowerLimitRackDisplacement; //!< flag "is LowerLimitRackDisplacement defined"
+ Standard_Boolean defUpperLimitRackDisplacement; //!< flag "is UpperLimitRackDisplacement defined"
+
+};
+#endif // _StepKinematics_RackAndPinionPairWithRange_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_RevolutePair.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_RevolutePair, StepKinematics_LowOrderKinematicPair)
+
+//=======================================================================
+//function : StepKinematics_RevolutePair
+//purpose :
+//=======================================================================
+StepKinematics_RevolutePair::StepKinematics_RevolutePair ()
+{
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_RevolutePair_HeaderFile_
+#define _StepKinematics_RevolutePair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_LowOrderKinematicPair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_RevolutePair, StepKinematics_LowOrderKinematicPair)
+
+//! Representation of STEP entity RevolutePair
+class StepKinematics_RevolutePair : public StepKinematics_LowOrderKinematicPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_RevolutePair();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_RevolutePair, StepKinematics_LowOrderKinematicPair)
+
+};
+#endif // _StepKinematics_RevolutePair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_RevolutePairValue.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_RevolutePairValue, StepKinematics_PairValue)
+
+//=======================================================================
+//function : StepKinematics_RevolutePairValue
+//purpose :
+//=======================================================================
+StepKinematics_RevolutePairValue::StepKinematics_RevolutePairValue ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_RevolutePairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Standard_Real theActualRotation)
+{
+ StepKinematics_PairValue::Init(theRepresentationItem_Name,
+ thePairValue_AppliesToPair);
+
+ myActualRotation = theActualRotation;
+}
+
+//=======================================================================
+//function : ActualRotation
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_RevolutePairValue::ActualRotation () const
+{
+ return myActualRotation;
+}
+
+//=======================================================================
+//function : SetActualRotation
+//purpose :
+//=======================================================================
+void StepKinematics_RevolutePairValue::SetActualRotation (const Standard_Real theActualRotation)
+{
+ myActualRotation = theActualRotation;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_RevolutePairValue_HeaderFile_
+#define _StepKinematics_RevolutePairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_PairValue.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_RevolutePairValue, StepKinematics_PairValue)
+
+//! Representation of STEP entity RevolutePairValue
+class StepKinematics_RevolutePairValue : public StepKinematics_PairValue
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_RevolutePairValue();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Standard_Real theActualRotation);
+
+ //! Returns field ActualRotation
+ Standard_EXPORT Standard_Real ActualRotation() const;
+ //! Sets field ActualRotation
+ Standard_EXPORT void SetActualRotation (const Standard_Real theActualRotation);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_RevolutePairValue, StepKinematics_PairValue)
+
+private:
+ Standard_Real myActualRotation;
+
+};
+#endif // _StepKinematics_RevolutePairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_RevolutePairWithRange.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_RevolutePairWithRange, StepKinematics_RevolutePair)
+
+//=======================================================================
+//function : StepKinematics_RevolutePairWithRange
+//purpose :
+//=======================================================================
+StepKinematics_RevolutePairWithRange::StepKinematics_RevolutePairWithRange ()
+{
+ defLowerLimitActualRotation = Standard_False;
+ defUpperLimitActualRotation = Standard_False;
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_RevolutePairWithRange::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Boolean theLowOrderKinematicPair_TX,
+ const Standard_Boolean theLowOrderKinematicPair_TY,
+ const Standard_Boolean theLowOrderKinematicPair_TZ,
+ const Standard_Boolean theLowOrderKinematicPair_RX,
+ const Standard_Boolean theLowOrderKinematicPair_RY,
+ const Standard_Boolean theLowOrderKinematicPair_RZ,
+ const Standard_Boolean hasLowerLimitActualRotation,
+ const Standard_Real theLowerLimitActualRotation,
+ const Standard_Boolean hasUpperLimitActualRotation,
+ const Standard_Real theUpperLimitActualRotation)
+{
+ StepKinematics_RevolutePair::Init(theRepresentationItem_Name,
+ theItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2,
+ theKinematicPair_Joint,
+ theLowOrderKinematicPair_TX,
+ theLowOrderKinematicPair_TY,
+ theLowOrderKinematicPair_TZ,
+ theLowOrderKinematicPair_RX,
+ theLowOrderKinematicPair_RY,
+ theLowOrderKinematicPair_RZ);
+
+ defLowerLimitActualRotation = hasLowerLimitActualRotation;
+ if (defLowerLimitActualRotation) {
+ myLowerLimitActualRotation = theLowerLimitActualRotation;
+ }
+ else myLowerLimitActualRotation = 0;
+
+ defUpperLimitActualRotation = hasUpperLimitActualRotation;
+ if (defUpperLimitActualRotation) {
+ myUpperLimitActualRotation = theUpperLimitActualRotation;
+ }
+ else myUpperLimitActualRotation = 0;
+}
+
+//=======================================================================
+//function : LowerLimitActualRotation
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_RevolutePairWithRange::LowerLimitActualRotation () const
+{
+ return myLowerLimitActualRotation;
+}
+
+//=======================================================================
+//function : SetLowerLimitActualRotation
+//purpose :
+//=======================================================================
+void StepKinematics_RevolutePairWithRange::SetLowerLimitActualRotation (const Standard_Real theLowerLimitActualRotation)
+{
+ myLowerLimitActualRotation = theLowerLimitActualRotation;
+}
+
+//=======================================================================
+//function : HasLowerLimitActualRotation
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_RevolutePairWithRange::HasLowerLimitActualRotation () const
+{
+ return defLowerLimitActualRotation;
+}
+
+//=======================================================================
+//function : UpperLimitActualRotation
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_RevolutePairWithRange::UpperLimitActualRotation () const
+{
+ return myUpperLimitActualRotation;
+}
+
+//=======================================================================
+//function : SetUpperLimitActualRotation
+//purpose :
+//=======================================================================
+void StepKinematics_RevolutePairWithRange::SetUpperLimitActualRotation (const Standard_Real theUpperLimitActualRotation)
+{
+ myUpperLimitActualRotation = theUpperLimitActualRotation;
+}
+
+//=======================================================================
+//function : HasUpperLimitActualRotation
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_RevolutePairWithRange::HasUpperLimitActualRotation () const
+{
+ return defUpperLimitActualRotation;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_RevolutePairWithRange_HeaderFile_
+#define _StepKinematics_RevolutePairWithRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_RevolutePair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_RevolutePairWithRange, StepKinematics_RevolutePair)
+
+//! Representation of STEP entity RevolutePairWithRange
+class StepKinematics_RevolutePairWithRange : public StepKinematics_RevolutePair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_RevolutePairWithRange();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Boolean theLowOrderKinematicPair_TX,
+ const Standard_Boolean theLowOrderKinematicPair_TY,
+ const Standard_Boolean theLowOrderKinematicPair_TZ,
+ const Standard_Boolean theLowOrderKinematicPair_RX,
+ const Standard_Boolean theLowOrderKinematicPair_RY,
+ const Standard_Boolean theLowOrderKinematicPair_RZ,
+ const Standard_Boolean hasLowerLimitActualRotation,
+ const Standard_Real theLowerLimitActualRotation,
+ const Standard_Boolean hasUpperLimitActualRotation,
+ const Standard_Real theUpperLimitActualRotation);
+
+ //! Returns field LowerLimitActualRotation
+ Standard_EXPORT Standard_Real LowerLimitActualRotation() const;
+ //! Sets field LowerLimitActualRotation
+ Standard_EXPORT void SetLowerLimitActualRotation (const Standard_Real theLowerLimitActualRotation);
+ //! Returns True if optional field LowerLimitActualRotation is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitActualRotation() const;
+
+ //! Returns field UpperLimitActualRotation
+ Standard_EXPORT Standard_Real UpperLimitActualRotation() const;
+ //! Sets field UpperLimitActualRotation
+ Standard_EXPORT void SetUpperLimitActualRotation (const Standard_Real theUpperLimitActualRotation);
+ //! Returns True if optional field UpperLimitActualRotation is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitActualRotation() const;
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_RevolutePairWithRange, StepKinematics_RevolutePair)
+
+private:
+ Standard_Real myLowerLimitActualRotation; //!< optional
+ Standard_Real myUpperLimitActualRotation; //!< optional
+ Standard_Boolean defLowerLimitActualRotation; //!< flag "is LowerLimitActualRotation defined"
+ Standard_Boolean defUpperLimitActualRotation; //!< flag "is UpperLimitActualRotation defined"
+
+};
+#endif // _StepKinematics_RevolutePairWithRange_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_RigidLinkRepresentation.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_RigidLinkRepresentation, StepKinematics_KinematicLinkRepresentation)
+
+//=======================================================================
+//function : StepKinematics_RigidLinkRepresentation
+//purpose :
+//=======================================================================
+StepKinematics_RigidLinkRepresentation::StepKinematics_RigidLinkRepresentation ()
+{
+}
--- /dev/null
+// Created on : Sat May 02 12:41:15 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_RigidLinkRepresentation_HeaderFile_
+#define _StepKinematics_RigidLinkRepresentation_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_KinematicLinkRepresentation.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_RepresentationContext.hxx>
+#include <StepKinematics_KinematicLink.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_RigidLinkRepresentation, StepKinematics_KinematicLinkRepresentation)
+
+//! Representation of STEP entity RigidLinkRepresentation
+class StepKinematics_RigidLinkRepresentation : public StepKinematics_KinematicLinkRepresentation
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_RigidLinkRepresentation();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_RigidLinkRepresentation, StepKinematics_KinematicLinkRepresentation)
+
+};
+#endif // _StepKinematics_RigidLinkRepresentation_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:14 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_RigidPlacement.hxx>
+#include <StepGeom_Axis2Placement3d.hxx>
+#include <StepGeom_SuParameters.hxx>
+
+//=======================================================================
+//function : StepKinematics_RigidPlacement
+//purpose :
+//=======================================================================
+StepKinematics_RigidPlacement::StepKinematics_RigidPlacement ()
+{
+}
+
+//=======================================================================
+//function : CaseNum
+//purpose :
+//=======================================================================
+Standard_Integer StepKinematics_RigidPlacement::CaseNum (const Handle(Standard_Transient)& ent) const
+{
+ if (ent.IsNull()) return 0;
+ if (ent->IsKind(STANDARD_TYPE(StepGeom_Axis2Placement3d))) return 1;
+ if (ent->IsKind(STANDARD_TYPE(StepGeom_SuParameters))) return 2;
+ return 0;
+}
+
+//=======================================================================
+//function : Axis2Placement3d
+//purpose :
+//=======================================================================
+Handle(StepGeom_Axis2Placement3d) StepKinematics_RigidPlacement::Axis2Placement3d () const
+{
+ return Handle(StepGeom_Axis2Placement3d)::DownCast(Value());
+}
+
+//=======================================================================
+//function : SuParameters
+//purpose :
+//=======================================================================
+Handle(StepGeom_SuParameters) StepKinematics_RigidPlacement::SuParameters () const
+{
+ return Handle(StepGeom_SuParameters)::DownCast(Value());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:14 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_RigidPlacement_HeaderFile
+#define _StepKinematics_RigidPlacement_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+#include <StepData_SelectType.hxx>
+#include <Standard_Integer.hxx>
+
+class Standard_Transient;
+class StepGeom_Axis2Placement3d;
+class StepGeom_SuParameters;
+
+//! Representation of STEP SELECT type RigidPlacement
+class StepKinematics_RigidPlacement : public StepData_SelectType
+{
+
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ //! Empty constructor
+ Standard_EXPORT StepKinematics_RigidPlacement();
+
+ //! Recognizes a kind of RigidPlacement select type
+ //! -- 1 -> Axis2Placement3d
+ //! -- 2 -> SuParameters
+ Standard_EXPORT Standard_Integer CaseNum (const Handle(Standard_Transient)& ent) const Standard_OVERRIDE;
+
+ //! Returns Value as Axis2Placement3d (or Null if another type)
+ Standard_EXPORT Handle(StepGeom_Axis2Placement3d) Axis2Placement3d() const;
+
+ //! Returns Value as SuParameters (or Null if another type)
+ Standard_EXPORT Handle(StepGeom_SuParameters) SuParameters() const;
+
+};
+#endif // _StepKinematics_RigidPlacement_HeaderFile
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_RollingCurvePair.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_RollingCurvePair, StepKinematics_PlanarCurvePair)
+
+//=======================================================================
+//function : StepKinematics_RollingCurvePair
+//purpose :
+//=======================================================================
+StepKinematics_RollingCurvePair::StepKinematics_RollingCurvePair ()
+{
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_RollingCurvePair_HeaderFile_
+#define _StepKinematics_RollingCurvePair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_PlanarCurvePair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Curve.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_RollingCurvePair, StepKinematics_PlanarCurvePair)
+
+//! Representation of STEP entity RollingCurvePair
+class StepKinematics_RollingCurvePair : public StepKinematics_PlanarCurvePair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_RollingCurvePair();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_RollingCurvePair, StepKinematics_PlanarCurvePair)
+
+};
+#endif // _StepKinematics_RollingCurvePair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_RollingCurvePairValue.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_RollingCurvePairValue, StepKinematics_PairValue)
+
+//=======================================================================
+//function : StepKinematics_RollingCurvePairValue
+//purpose :
+//=======================================================================
+StepKinematics_RollingCurvePairValue::StepKinematics_RollingCurvePairValue ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_RollingCurvePairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve1)
+{
+ StepKinematics_PairValue::Init(theRepresentationItem_Name,
+ thePairValue_AppliesToPair);
+
+ myActualPointOnCurve1 = theActualPointOnCurve1;
+}
+
+//=======================================================================
+//function : ActualPointOnCurve1
+//purpose :
+//=======================================================================
+Handle(StepGeom_PointOnCurve) StepKinematics_RollingCurvePairValue::ActualPointOnCurve1 () const
+{
+ return myActualPointOnCurve1;
+}
+
+//=======================================================================
+//function : SetActualPointOnCurve1
+//purpose :
+//=======================================================================
+void StepKinematics_RollingCurvePairValue::SetActualPointOnCurve1 (const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve1)
+{
+ myActualPointOnCurve1 = theActualPointOnCurve1;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_RollingCurvePairValue_HeaderFile_
+#define _StepKinematics_RollingCurvePairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_PairValue.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <StepGeom_PointOnCurve.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_RollingCurvePairValue, StepKinematics_PairValue)
+
+//! Representation of STEP entity RollingCurvePairValue
+class StepKinematics_RollingCurvePairValue : public StepKinematics_PairValue
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_RollingCurvePairValue();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve1);
+
+ //! Returns field ActualPointOnCurve1
+ Standard_EXPORT Handle(StepGeom_PointOnCurve) ActualPointOnCurve1() const;
+ //! Sets field ActualPointOnCurve1
+ Standard_EXPORT void SetActualPointOnCurve1 (const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve1);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_RollingCurvePairValue, StepKinematics_PairValue)
+
+private:
+ Handle(StepGeom_PointOnCurve) myActualPointOnCurve1;
+
+};
+#endif // _StepKinematics_RollingCurvePairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_RollingSurfacePair.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_RollingSurfacePair, StepKinematics_SurfacePair)
+
+//=======================================================================
+//function : StepKinematics_RollingSurfacePair
+//purpose :
+//=======================================================================
+StepKinematics_RollingSurfacePair::StepKinematics_RollingSurfacePair ()
+{
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_RollingSurfacePair_HeaderFile_
+#define _StepKinematics_RollingSurfacePair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_SurfacePair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Surface.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_RollingSurfacePair, StepKinematics_SurfacePair)
+
+//! Representation of STEP entity RollingSurfacePair
+class StepKinematics_RollingSurfacePair : public StepKinematics_SurfacePair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_RollingSurfacePair();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_RollingSurfacePair, StepKinematics_SurfacePair)
+
+};
+#endif // _StepKinematics_RollingSurfacePair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_RollingSurfacePairValue.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_RollingSurfacePairValue, StepKinematics_PairValue)
+
+//=======================================================================
+//function : StepKinematics_RollingSurfacePairValue
+//purpose :
+//=======================================================================
+StepKinematics_RollingSurfacePairValue::StepKinematics_RollingSurfacePairValue ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_RollingSurfacePairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface,
+ const Standard_Real theActualRotation)
+{
+ StepKinematics_PairValue::Init(theRepresentationItem_Name,
+ thePairValue_AppliesToPair);
+
+ myActualPointOnSurface = theActualPointOnSurface;
+
+ myActualRotation = theActualRotation;
+}
+
+//=======================================================================
+//function : ActualPointOnSurface
+//purpose :
+//=======================================================================
+Handle(StepGeom_PointOnSurface) StepKinematics_RollingSurfacePairValue::ActualPointOnSurface () const
+{
+ return myActualPointOnSurface;
+}
+
+//=======================================================================
+//function : SetActualPointOnSurface
+//purpose :
+//=======================================================================
+void StepKinematics_RollingSurfacePairValue::SetActualPointOnSurface (const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface)
+{
+ myActualPointOnSurface = theActualPointOnSurface;
+}
+
+//=======================================================================
+//function : ActualRotation
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_RollingSurfacePairValue::ActualRotation () const
+{
+ return myActualRotation;
+}
+
+//=======================================================================
+//function : SetActualRotation
+//purpose :
+//=======================================================================
+void StepKinematics_RollingSurfacePairValue::SetActualRotation (const Standard_Real theActualRotation)
+{
+ myActualRotation = theActualRotation;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_RollingSurfacePairValue_HeaderFile_
+#define _StepKinematics_RollingSurfacePairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_PairValue.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <StepGeom_PointOnSurface.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_RollingSurfacePairValue, StepKinematics_PairValue)
+
+//! Representation of STEP entity RollingSurfacePairValue
+class StepKinematics_RollingSurfacePairValue : public StepKinematics_PairValue
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_RollingSurfacePairValue();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface,
+ const Standard_Real theActualRotation);
+
+ //! Returns field ActualPointOnSurface
+ Standard_EXPORT Handle(StepGeom_PointOnSurface) ActualPointOnSurface() const;
+ //! Sets field ActualPointOnSurface
+ Standard_EXPORT void SetActualPointOnSurface (const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface);
+
+ //! Returns field ActualRotation
+ Standard_EXPORT Standard_Real ActualRotation() const;
+ //! Sets field ActualRotation
+ Standard_EXPORT void SetActualRotation (const Standard_Real theActualRotation);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_RollingSurfacePairValue, StepKinematics_PairValue)
+
+private:
+ Handle(StepGeom_PointOnSurface) myActualPointOnSurface;
+ Standard_Real myActualRotation;
+
+};
+#endif // _StepKinematics_RollingSurfacePairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:14 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_RotationAboutDirection.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_RotationAboutDirection, StepGeom_GeometricRepresentationItem)
+
+//=======================================================================
+//function : StepKinematics_RotationAboutDirection
+//purpose :
+//=======================================================================
+StepKinematics_RotationAboutDirection::StepKinematics_RotationAboutDirection ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_RotationAboutDirection::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepGeom_Direction)& theDirectionOfAxis,
+ const Standard_Real theRotationAngle)
+{
+ StepGeom_GeometricRepresentationItem::Init(theRepresentationItem_Name);
+
+ myDirectionOfAxis = theDirectionOfAxis;
+
+ myRotationAngle = theRotationAngle;
+}
+
+//=======================================================================
+//function : DirectionOfAxis
+//purpose :
+//=======================================================================
+Handle(StepGeom_Direction) StepKinematics_RotationAboutDirection::DirectionOfAxis () const
+{
+ return myDirectionOfAxis;
+}
+
+//=======================================================================
+//function : SetDirectionOfAxis
+//purpose :
+//=======================================================================
+void StepKinematics_RotationAboutDirection::SetDirectionOfAxis (const Handle(StepGeom_Direction)& theDirectionOfAxis)
+{
+ myDirectionOfAxis = theDirectionOfAxis;
+}
+
+//=======================================================================
+//function : RotationAngle
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_RotationAboutDirection::RotationAngle () const
+{
+ return myRotationAngle;
+}
+
+//=======================================================================
+//function : SetRotationAngle
+//purpose :
+//=======================================================================
+void StepKinematics_RotationAboutDirection::SetRotationAngle (const Standard_Real theRotationAngle)
+{
+ myRotationAngle = theRotationAngle;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:14 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_RotationAboutDirection_HeaderFile_
+#define _StepKinematics_RotationAboutDirection_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepGeom_GeometricRepresentationItem.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepGeom_Direction.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_RotationAboutDirection, StepGeom_GeometricRepresentationItem)
+
+//! Representation of STEP entity RotationAboutDirection
+class StepKinematics_RotationAboutDirection : public StepGeom_GeometricRepresentationItem
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_RotationAboutDirection();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepGeom_Direction)& theDirectionOfAxis,
+ const Standard_Real theRotationAngle);
+
+ //! Returns field DirectionOfAxis
+ Standard_EXPORT Handle(StepGeom_Direction) DirectionOfAxis() const;
+ //! Sets field DirectionOfAxis
+ Standard_EXPORT void SetDirectionOfAxis (const Handle(StepGeom_Direction)& theDirectionOfAxis);
+
+ //! Returns field RotationAngle
+ Standard_EXPORT Standard_Real RotationAngle() const;
+ //! Sets field RotationAngle
+ Standard_EXPORT void SetRotationAngle (const Standard_Real theRotationAngle);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_RotationAboutDirection, StepGeom_GeometricRepresentationItem)
+
+private:
+ Handle(StepGeom_Direction) myDirectionOfAxis;
+ Standard_Real myRotationAngle;
+
+};
+#endif // _StepKinematics_RotationAboutDirection_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_ScrewPair.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_ScrewPair, StepKinematics_LowOrderKinematicPairWithMotionCoupling)
+
+//=======================================================================
+//function : StepKinematics_ScrewPair
+//purpose :
+//=======================================================================
+StepKinematics_ScrewPair::StepKinematics_ScrewPair ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_ScrewPair::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Real thePitch)
+{
+ StepKinematics_LowOrderKinematicPairWithMotionCoupling::Init(theRepresentationItem_Name,
+ theItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2,
+ theKinematicPair_Joint);
+
+ myPitch = thePitch;
+}
+
+//=======================================================================
+//function : Pitch
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_ScrewPair::Pitch () const
+{
+ return myPitch;
+}
+
+//=======================================================================
+//function : SetPitch
+//purpose :
+//=======================================================================
+void StepKinematics_ScrewPair::SetPitch (const Standard_Real thePitch)
+{
+ myPitch = thePitch;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_ScrewPair_HeaderFile_
+#define _StepKinematics_ScrewPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_LowOrderKinematicPairWithMotionCoupling.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_ScrewPair, StepKinematics_LowOrderKinematicPairWithMotionCoupling)
+
+//! Representation of STEP entity ScrewPair
+class StepKinematics_ScrewPair : public StepKinematics_LowOrderKinematicPairWithMotionCoupling
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_ScrewPair();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Real thePitch);
+
+ //! Returns field Pitch
+ Standard_EXPORT Standard_Real Pitch() const;
+ //! Sets field Pitch
+ Standard_EXPORT void SetPitch (const Standard_Real thePitch);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_ScrewPair, StepKinematics_LowOrderKinematicPairWithMotionCoupling)
+
+private:
+ Standard_Real myPitch;
+
+};
+#endif // _StepKinematics_ScrewPair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_ScrewPairValue.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_ScrewPairValue, StepKinematics_PairValue)
+
+//=======================================================================
+//function : StepKinematics_ScrewPairValue
+//purpose :
+//=======================================================================
+StepKinematics_ScrewPairValue::StepKinematics_ScrewPairValue ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_ScrewPairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Standard_Real theActualRotation)
+{
+ StepKinematics_PairValue::Init(theRepresentationItem_Name,
+ thePairValue_AppliesToPair);
+
+ myActualRotation = theActualRotation;
+}
+
+//=======================================================================
+//function : ActualRotation
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_ScrewPairValue::ActualRotation () const
+{
+ return myActualRotation;
+}
+
+//=======================================================================
+//function : SetActualRotation
+//purpose :
+//=======================================================================
+void StepKinematics_ScrewPairValue::SetActualRotation (const Standard_Real theActualRotation)
+{
+ myActualRotation = theActualRotation;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_ScrewPairValue_HeaderFile_
+#define _StepKinematics_ScrewPairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_PairValue.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_ScrewPairValue, StepKinematics_PairValue)
+
+//! Representation of STEP entity ScrewPairValue
+class StepKinematics_ScrewPairValue : public StepKinematics_PairValue
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_ScrewPairValue();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Standard_Real theActualRotation);
+
+ //! Returns field ActualRotation
+ Standard_EXPORT Standard_Real ActualRotation() const;
+ //! Sets field ActualRotation
+ Standard_EXPORT void SetActualRotation (const Standard_Real theActualRotation);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_ScrewPairValue, StepKinematics_PairValue)
+
+private:
+ Standard_Real myActualRotation;
+
+};
+#endif // _StepKinematics_ScrewPairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_ScrewPairWithRange.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_ScrewPairWithRange, StepKinematics_ScrewPair)
+
+//=======================================================================
+//function : StepKinematics_ScrewPairWithRange
+//purpose :
+//=======================================================================
+StepKinematics_ScrewPairWithRange::StepKinematics_ScrewPairWithRange ()
+{
+ defLowerLimitActualRotation = Standard_False;
+ defUpperLimitActualRotation = Standard_False;
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_ScrewPairWithRange::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Real theScrewPair_Pitch,
+ const Standard_Boolean hasLowerLimitActualRotation,
+ const Standard_Real theLowerLimitActualRotation,
+ const Standard_Boolean hasUpperLimitActualRotation,
+ const Standard_Real theUpperLimitActualRotation)
+{
+ StepKinematics_ScrewPair::Init(theRepresentationItem_Name,
+ theItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2,
+ theKinematicPair_Joint,
+ theScrewPair_Pitch);
+
+ defLowerLimitActualRotation = hasLowerLimitActualRotation;
+ if (defLowerLimitActualRotation) {
+ myLowerLimitActualRotation = theLowerLimitActualRotation;
+ }
+ else myLowerLimitActualRotation = 0;
+
+ defUpperLimitActualRotation = hasUpperLimitActualRotation;
+ if (defUpperLimitActualRotation) {
+ myUpperLimitActualRotation = theUpperLimitActualRotation;
+ }
+ else myUpperLimitActualRotation = 0;
+}
+
+//=======================================================================
+//function : LowerLimitActualRotation
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_ScrewPairWithRange::LowerLimitActualRotation () const
+{
+ return myLowerLimitActualRotation;
+}
+
+//=======================================================================
+//function : SetLowerLimitActualRotation
+//purpose :
+//=======================================================================
+void StepKinematics_ScrewPairWithRange::SetLowerLimitActualRotation (const Standard_Real theLowerLimitActualRotation)
+{
+ myLowerLimitActualRotation = theLowerLimitActualRotation;
+}
+
+//=======================================================================
+//function : HasLowerLimitActualRotation
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_ScrewPairWithRange::HasLowerLimitActualRotation () const
+{
+ return defLowerLimitActualRotation;
+}
+
+//=======================================================================
+//function : UpperLimitActualRotation
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_ScrewPairWithRange::UpperLimitActualRotation () const
+{
+ return myUpperLimitActualRotation;
+}
+
+//=======================================================================
+//function : SetUpperLimitActualRotation
+//purpose :
+//=======================================================================
+void StepKinematics_ScrewPairWithRange::SetUpperLimitActualRotation (const Standard_Real theUpperLimitActualRotation)
+{
+ myUpperLimitActualRotation = theUpperLimitActualRotation;
+}
+
+//=======================================================================
+//function : HasUpperLimitActualRotation
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_ScrewPairWithRange::HasUpperLimitActualRotation () const
+{
+ return defUpperLimitActualRotation;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_ScrewPairWithRange_HeaderFile_
+#define _StepKinematics_ScrewPairWithRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_ScrewPair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_ScrewPairWithRange, StepKinematics_ScrewPair)
+
+//! Representation of STEP entity ScrewPairWithRange
+class StepKinematics_ScrewPairWithRange : public StepKinematics_ScrewPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_ScrewPairWithRange();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Real theScrewPair_Pitch,
+ const Standard_Boolean hasLowerLimitActualRotation,
+ const Standard_Real theLowerLimitActualRotation,
+ const Standard_Boolean hasUpperLimitActualRotation,
+ const Standard_Real theUpperLimitActualRotation);
+
+ //! Returns field LowerLimitActualRotation
+ Standard_EXPORT Standard_Real LowerLimitActualRotation() const;
+ //! Sets field LowerLimitActualRotation
+ Standard_EXPORT void SetLowerLimitActualRotation (const Standard_Real theLowerLimitActualRotation);
+ //! Returns True if optional field LowerLimitActualRotation is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitActualRotation() const;
+
+ //! Returns field UpperLimitActualRotation
+ Standard_EXPORT Standard_Real UpperLimitActualRotation() const;
+ //! Sets field UpperLimitActualRotation
+ Standard_EXPORT void SetUpperLimitActualRotation (const Standard_Real theUpperLimitActualRotation);
+ //! Returns True if optional field UpperLimitActualRotation is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitActualRotation() const;
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_ScrewPairWithRange, StepKinematics_ScrewPair)
+
+private:
+ Standard_Real myLowerLimitActualRotation; //!< optional
+ Standard_Real myUpperLimitActualRotation; //!< optional
+ Standard_Boolean defLowerLimitActualRotation; //!< flag "is LowerLimitActualRotation defined"
+ Standard_Boolean defUpperLimitActualRotation; //!< flag "is UpperLimitActualRotation defined"
+
+};
+#endif // _StepKinematics_ScrewPairWithRange_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_SlidingCurvePair.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_SlidingCurvePair, StepKinematics_PlanarCurvePair)
+
+//=======================================================================
+//function : StepKinematics_SlidingCurvePair
+//purpose :
+//=======================================================================
+StepKinematics_SlidingCurvePair::StepKinematics_SlidingCurvePair ()
+{
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_SlidingCurvePair_HeaderFile_
+#define _StepKinematics_SlidingCurvePair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_PlanarCurvePair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Curve.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_SlidingCurvePair, StepKinematics_PlanarCurvePair)
+
+//! Representation of STEP entity SlidingCurvePair
+class StepKinematics_SlidingCurvePair : public StepKinematics_PlanarCurvePair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_SlidingCurvePair();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_SlidingCurvePair, StepKinematics_PlanarCurvePair)
+
+};
+#endif // _StepKinematics_SlidingCurvePair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_SlidingCurvePairValue.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_SlidingCurvePairValue, StepKinematics_PairValue)
+
+//=======================================================================
+//function : StepKinematics_SlidingCurvePairValue
+//purpose :
+//=======================================================================
+StepKinematics_SlidingCurvePairValue::StepKinematics_SlidingCurvePairValue ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_SlidingCurvePairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve1,
+ const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve2)
+{
+ StepKinematics_PairValue::Init(theRepresentationItem_Name,
+ thePairValue_AppliesToPair);
+
+ myActualPointOnCurve1 = theActualPointOnCurve1;
+
+ myActualPointOnCurve2 = theActualPointOnCurve2;
+}
+
+//=======================================================================
+//function : ActualPointOnCurve1
+//purpose :
+//=======================================================================
+Handle(StepGeom_PointOnCurve) StepKinematics_SlidingCurvePairValue::ActualPointOnCurve1 () const
+{
+ return myActualPointOnCurve1;
+}
+
+//=======================================================================
+//function : SetActualPointOnCurve1
+//purpose :
+//=======================================================================
+void StepKinematics_SlidingCurvePairValue::SetActualPointOnCurve1 (const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve1)
+{
+ myActualPointOnCurve1 = theActualPointOnCurve1;
+}
+
+//=======================================================================
+//function : ActualPointOnCurve2
+//purpose :
+//=======================================================================
+Handle(StepGeom_PointOnCurve) StepKinematics_SlidingCurvePairValue::ActualPointOnCurve2 () const
+{
+ return myActualPointOnCurve2;
+}
+
+//=======================================================================
+//function : SetActualPointOnCurve2
+//purpose :
+//=======================================================================
+void StepKinematics_SlidingCurvePairValue::SetActualPointOnCurve2 (const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve2)
+{
+ myActualPointOnCurve2 = theActualPointOnCurve2;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_SlidingCurvePairValue_HeaderFile_
+#define _StepKinematics_SlidingCurvePairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_PairValue.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <StepGeom_PointOnCurve.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_SlidingCurvePairValue, StepKinematics_PairValue)
+
+//! Representation of STEP entity SlidingCurvePairValue
+class StepKinematics_SlidingCurvePairValue : public StepKinematics_PairValue
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_SlidingCurvePairValue();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve1,
+ const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve2);
+
+ //! Returns field ActualPointOnCurve1
+ Standard_EXPORT Handle(StepGeom_PointOnCurve) ActualPointOnCurve1() const;
+ //! Sets field ActualPointOnCurve1
+ Standard_EXPORT void SetActualPointOnCurve1 (const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve1);
+
+ //! Returns field ActualPointOnCurve2
+ Standard_EXPORT Handle(StepGeom_PointOnCurve) ActualPointOnCurve2() const;
+ //! Sets field ActualPointOnCurve2
+ Standard_EXPORT void SetActualPointOnCurve2 (const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve2);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_SlidingCurvePairValue, StepKinematics_PairValue)
+
+private:
+ Handle(StepGeom_PointOnCurve) myActualPointOnCurve1;
+ Handle(StepGeom_PointOnCurve) myActualPointOnCurve2;
+
+};
+#endif // _StepKinematics_SlidingCurvePairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_SlidingSurfacePair.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_SlidingSurfacePair, StepKinematics_SurfacePair)
+
+//=======================================================================
+//function : StepKinematics_SlidingSurfacePair
+//purpose :
+//=======================================================================
+StepKinematics_SlidingSurfacePair::StepKinematics_SlidingSurfacePair ()
+{
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_SlidingSurfacePair_HeaderFile_
+#define _StepKinematics_SlidingSurfacePair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_SurfacePair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Surface.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_SlidingSurfacePair, StepKinematics_SurfacePair)
+
+//! Representation of STEP entity SlidingSurfacePair
+class StepKinematics_SlidingSurfacePair : public StepKinematics_SurfacePair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_SlidingSurfacePair();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_SlidingSurfacePair, StepKinematics_SurfacePair)
+
+};
+#endif // _StepKinematics_SlidingSurfacePair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_SlidingSurfacePairValue.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_SlidingSurfacePairValue, StepKinematics_PairValue)
+
+//=======================================================================
+//function : StepKinematics_SlidingSurfacePairValue
+//purpose :
+//=======================================================================
+StepKinematics_SlidingSurfacePairValue::StepKinematics_SlidingSurfacePairValue ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_SlidingSurfacePairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface1,
+ const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface2,
+ const Standard_Real theActualRotation)
+{
+ StepKinematics_PairValue::Init(theRepresentationItem_Name,
+ thePairValue_AppliesToPair);
+
+ myActualPointOnSurface1 = theActualPointOnSurface1;
+
+ myActualPointOnSurface2 = theActualPointOnSurface2;
+
+ myActualRotation = theActualRotation;
+}
+
+//=======================================================================
+//function : ActualPointOnSurface1
+//purpose :
+//=======================================================================
+Handle(StepGeom_PointOnSurface) StepKinematics_SlidingSurfacePairValue::ActualPointOnSurface1 () const
+{
+ return myActualPointOnSurface1;
+}
+
+//=======================================================================
+//function : SetActualPointOnSurface1
+//purpose :
+//=======================================================================
+void StepKinematics_SlidingSurfacePairValue::SetActualPointOnSurface1 (const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface1)
+{
+ myActualPointOnSurface1 = theActualPointOnSurface1;
+}
+
+//=======================================================================
+//function : ActualPointOnSurface2
+//purpose :
+//=======================================================================
+Handle(StepGeom_PointOnSurface) StepKinematics_SlidingSurfacePairValue::ActualPointOnSurface2 () const
+{
+ return myActualPointOnSurface2;
+}
+
+//=======================================================================
+//function : SetActualPointOnSurface2
+//purpose :
+//=======================================================================
+void StepKinematics_SlidingSurfacePairValue::SetActualPointOnSurface2 (const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface2)
+{
+ myActualPointOnSurface2 = theActualPointOnSurface2;
+}
+
+//=======================================================================
+//function : ActualRotation
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_SlidingSurfacePairValue::ActualRotation () const
+{
+ return myActualRotation;
+}
+
+//=======================================================================
+//function : SetActualRotation
+//purpose :
+//=======================================================================
+void StepKinematics_SlidingSurfacePairValue::SetActualRotation (const Standard_Real theActualRotation)
+{
+ myActualRotation = theActualRotation;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_SlidingSurfacePairValue_HeaderFile_
+#define _StepKinematics_SlidingSurfacePairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_PairValue.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <StepGeom_PointOnSurface.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_SlidingSurfacePairValue, StepKinematics_PairValue)
+
+//! Representation of STEP entity SlidingSurfacePairValue
+class StepKinematics_SlidingSurfacePairValue : public StepKinematics_PairValue
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_SlidingSurfacePairValue();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface1,
+ const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface2,
+ const Standard_Real theActualRotation);
+
+ //! Returns field ActualPointOnSurface1
+ Standard_EXPORT Handle(StepGeom_PointOnSurface) ActualPointOnSurface1() const;
+ //! Sets field ActualPointOnSurface1
+ Standard_EXPORT void SetActualPointOnSurface1 (const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface1);
+
+ //! Returns field ActualPointOnSurface2
+ Standard_EXPORT Handle(StepGeom_PointOnSurface) ActualPointOnSurface2() const;
+ //! Sets field ActualPointOnSurface2
+ Standard_EXPORT void SetActualPointOnSurface2 (const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface2);
+
+ //! Returns field ActualRotation
+ Standard_EXPORT Standard_Real ActualRotation() const;
+ //! Sets field ActualRotation
+ Standard_EXPORT void SetActualRotation (const Standard_Real theActualRotation);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_SlidingSurfacePairValue, StepKinematics_PairValue)
+
+private:
+ Handle(StepGeom_PointOnSurface) myActualPointOnSurface1;
+ Handle(StepGeom_PointOnSurface) myActualPointOnSurface2;
+ Standard_Real myActualRotation;
+
+};
+#endif // _StepKinematics_SlidingSurfacePairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:14 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_SpatialRotation.hxx>
+#include <StepKinematics_RotationAboutDirection.hxx>
+#include <TColStd_HArray1OfReal.hxx>
+
+//=======================================================================
+//function : StepKinematics_SpatialRotation
+//purpose :
+//=======================================================================
+StepKinematics_SpatialRotation::StepKinematics_SpatialRotation ()
+{
+}
+
+//=======================================================================
+//function : CaseNum
+//purpose :
+//=======================================================================
+Standard_Integer StepKinematics_SpatialRotation::CaseNum (const Handle(Standard_Transient)& ent) const
+{
+ if (ent.IsNull()) return 0;
+ if (ent->IsKind(STANDARD_TYPE(StepKinematics_RotationAboutDirection))) return 1;
+ if (ent->IsKind(STANDARD_TYPE(TColStd_HArray1OfReal))) return 2;
+ return 0;
+}
+
+//=======================================================================
+//function : RotationAboutDirection
+//purpose :
+//=======================================================================
+Handle(StepKinematics_RotationAboutDirection) StepKinematics_SpatialRotation::RotationAboutDirection () const
+{
+ return Handle(StepKinematics_RotationAboutDirection)::DownCast(Value());
+}
+
+//=======================================================================
+//function : YprRotation
+//purpose :
+//=======================================================================
+Handle(TColStd_HArray1OfReal) StepKinematics_SpatialRotation::YprRotation () const
+{
+ return Handle(TColStd_HArray1OfReal)::DownCast(Value());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:14 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_SpatialRotation_HeaderFile
+#define _StepKinematics_SpatialRotation_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+#include <StepData_SelectType.hxx>
+#include <Standard_Integer.hxx>
+
+class Standard_Transient;
+class StepKinematics_RotationAboutDirection;
+class TColStd_HArray1OfReal;
+
+//! Representation of STEP SELECT type SpatialRotation
+class StepKinematics_SpatialRotation : public StepData_SelectType
+{
+
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ //! Empty constructor
+ Standard_EXPORT StepKinematics_SpatialRotation();
+
+ //! Recognizes a kind of SpatialRotation select type
+ //! -- 1 -> RotationAboutDirection
+ //! -- 2 -> YprRotation
+ Standard_EXPORT Standard_Integer CaseNum (const Handle(Standard_Transient)& ent) const Standard_OVERRIDE;
+
+ //! Returns Value as RotationAboutDirection (or Null if another type)
+ Standard_EXPORT Handle(StepKinematics_RotationAboutDirection) RotationAboutDirection() const;
+
+ //! Returns Value as YprRotation (or Null if another type)
+ Standard_EXPORT Handle(TColStd_HArray1OfReal) YprRotation() const;
+
+};
+#endif // _StepKinematics_SpatialRotation_HeaderFile
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_SphericalPair.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_SphericalPair, StepKinematics_LowOrderKinematicPair)
+
+//=======================================================================
+//function : StepKinematics_SphericalPair
+//purpose :
+//=======================================================================
+StepKinematics_SphericalPair::StepKinematics_SphericalPair ()
+{
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_SphericalPair_HeaderFile_
+#define _StepKinematics_SphericalPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_LowOrderKinematicPair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_SphericalPair, StepKinematics_LowOrderKinematicPair)
+
+//! Representation of STEP entity SphericalPair
+class StepKinematics_SphericalPair : public StepKinematics_LowOrderKinematicPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_SphericalPair();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_SphericalPair, StepKinematics_LowOrderKinematicPair)
+
+};
+#endif // _StepKinematics_SphericalPair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:14 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_SphericalPairSelect.hxx>
+#include <StepKinematics_SphericalPair.hxx>
+#include <StepKinematics_SphericalPairWithPin.hxx>
+
+//=======================================================================
+//function : StepKinematics_SphericalPairSelect
+//purpose :
+//=======================================================================
+StepKinematics_SphericalPairSelect::StepKinematics_SphericalPairSelect ()
+{
+}
+
+//=======================================================================
+//function : CaseNum
+//purpose :
+//=======================================================================
+Standard_Integer StepKinematics_SphericalPairSelect::CaseNum (const Handle(Standard_Transient)& ent) const
+{
+ if (ent.IsNull()) return 0;
+ if (ent->IsKind(STANDARD_TYPE(StepKinematics_SphericalPair))) return 1;
+ if (ent->IsKind(STANDARD_TYPE(StepKinematics_SphericalPairWithPin))) return 2;
+ return 0;
+}
+
+//=======================================================================
+//function : SphericalPair
+//purpose :
+//=======================================================================
+Handle(StepKinematics_SphericalPair) StepKinematics_SphericalPairSelect::SphericalPair () const
+{
+ return Handle(StepKinematics_SphericalPair)::DownCast(Value());
+}
+
+//=======================================================================
+//function : SphericalPairWithPin
+//purpose :
+//=======================================================================
+Handle(StepKinematics_SphericalPairWithPin) StepKinematics_SphericalPairSelect::SphericalPairWithPin () const
+{
+ return Handle(StepKinematics_SphericalPairWithPin)::DownCast(Value());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:14 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_SphericalPairSelect_HeaderFile
+#define _StepKinematics_SphericalPairSelect_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+#include <StepData_SelectType.hxx>
+#include <Standard_Integer.hxx>
+
+class Standard_Transient;
+class StepKinematics_SphericalPair;
+class StepKinematics_SphericalPairWithPin;
+
+//! Representation of STEP SELECT type SphericalPairSelect
+class StepKinematics_SphericalPairSelect : public StepData_SelectType
+{
+
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ //! Empty constructor
+ Standard_EXPORT StepKinematics_SphericalPairSelect();
+
+ //! Recognizes a kind of SphericalPairSelect select type
+ //! -- 1 -> SphericalPair
+ //! -- 2 -> SphericalPairWithPin
+ Standard_EXPORT Standard_Integer CaseNum (const Handle(Standard_Transient)& ent) const Standard_OVERRIDE;
+
+ //! Returns Value as SphericalPair (or Null if another type)
+ Standard_EXPORT Handle(StepKinematics_SphericalPair) SphericalPair() const;
+
+ //! Returns Value as SphericalPairWithPin (or Null if another type)
+ Standard_EXPORT Handle(StepKinematics_SphericalPairWithPin) SphericalPairWithPin() const;
+
+};
+#endif // _StepKinematics_SphericalPairSelect_HeaderFile
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_SphericalPairValue.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_SphericalPairValue, StepKinematics_PairValue)
+
+//=======================================================================
+//function : StepKinematics_SphericalPairValue
+//purpose :
+//=======================================================================
+StepKinematics_SphericalPairValue::StepKinematics_SphericalPairValue ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_SphericalPairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const StepKinematics_SpatialRotation& theInputOrientation)
+{
+ StepKinematics_PairValue::Init(theRepresentationItem_Name,
+ thePairValue_AppliesToPair);
+
+ myInputOrientation = theInputOrientation;
+}
+
+//=======================================================================
+//function : InputOrientation
+//purpose :
+//=======================================================================
+StepKinematics_SpatialRotation StepKinematics_SphericalPairValue::InputOrientation () const
+{
+ return myInputOrientation;
+}
+
+//=======================================================================
+//function : SetInputOrientation
+//purpose :
+//=======================================================================
+void StepKinematics_SphericalPairValue::SetInputOrientation (const StepKinematics_SpatialRotation& theInputOrientation)
+{
+ myInputOrientation = theInputOrientation;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_SphericalPairValue_HeaderFile_
+#define _StepKinematics_SphericalPairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_PairValue.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <StepKinematics_SpatialRotation.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_SphericalPairValue, StepKinematics_PairValue)
+
+//! Representation of STEP entity SphericalPairValue
+class StepKinematics_SphericalPairValue : public StepKinematics_PairValue
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_SphericalPairValue();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const StepKinematics_SpatialRotation& theInputOrientation);
+
+ //! Returns field InputOrientation
+ Standard_EXPORT StepKinematics_SpatialRotation InputOrientation() const;
+ //! Sets field InputOrientation
+ Standard_EXPORT void SetInputOrientation (const StepKinematics_SpatialRotation& theInputOrientation);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_SphericalPairValue, StepKinematics_PairValue)
+
+private:
+ StepKinematics_SpatialRotation myInputOrientation;
+
+};
+#endif // _StepKinematics_SphericalPairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_SphericalPairWithPin.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_SphericalPairWithPin, StepKinematics_LowOrderKinematicPair)
+
+//=======================================================================
+//function : StepKinematics_SphericalPairWithPin
+//purpose :
+//=======================================================================
+StepKinematics_SphericalPairWithPin::StepKinematics_SphericalPairWithPin ()
+{
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_SphericalPairWithPin_HeaderFile_
+#define _StepKinematics_SphericalPairWithPin_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_LowOrderKinematicPair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_SphericalPairWithPin, StepKinematics_LowOrderKinematicPair)
+
+//! Representation of STEP entity SphericalPairWithPin
+class StepKinematics_SphericalPairWithPin : public StepKinematics_LowOrderKinematicPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_SphericalPairWithPin();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_SphericalPairWithPin, StepKinematics_LowOrderKinematicPair)
+
+};
+#endif // _StepKinematics_SphericalPairWithPin_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_SphericalPairWithPinAndRange.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_SphericalPairWithPinAndRange, StepKinematics_SphericalPairWithPin)
+
+//=======================================================================
+//function : StepKinematics_SphericalPairWithPinAndRange
+//purpose :
+//=======================================================================
+StepKinematics_SphericalPairWithPinAndRange::StepKinematics_SphericalPairWithPinAndRange ()
+{
+ defLowerLimitYaw = Standard_False;
+ defUpperLimitYaw = Standard_False;
+ defLowerLimitRoll = Standard_False;
+ defUpperLimitRoll = Standard_False;
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_SphericalPairWithPinAndRange::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Boolean theLowOrderKinematicPair_TX,
+ const Standard_Boolean theLowOrderKinematicPair_TY,
+ const Standard_Boolean theLowOrderKinematicPair_TZ,
+ const Standard_Boolean theLowOrderKinematicPair_RX,
+ const Standard_Boolean theLowOrderKinematicPair_RY,
+ const Standard_Boolean theLowOrderKinematicPair_RZ,
+ const Standard_Boolean hasLowerLimitYaw,
+ const Standard_Real theLowerLimitYaw,
+ const Standard_Boolean hasUpperLimitYaw,
+ const Standard_Real theUpperLimitYaw,
+ const Standard_Boolean hasLowerLimitRoll,
+ const Standard_Real theLowerLimitRoll,
+ const Standard_Boolean hasUpperLimitRoll,
+ const Standard_Real theUpperLimitRoll)
+{
+ StepKinematics_SphericalPairWithPin::Init(theRepresentationItem_Name,
+ theItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2,
+ theKinematicPair_Joint,
+ theLowOrderKinematicPair_TX,
+ theLowOrderKinematicPair_TY,
+ theLowOrderKinematicPair_TZ,
+ theLowOrderKinematicPair_RX,
+ theLowOrderKinematicPair_RY,
+ theLowOrderKinematicPair_RZ);
+
+ defLowerLimitYaw = hasLowerLimitYaw;
+ if (defLowerLimitYaw) {
+ myLowerLimitYaw = theLowerLimitYaw;
+ }
+ else myLowerLimitYaw = 0;
+
+ defUpperLimitYaw = hasUpperLimitYaw;
+ if (defUpperLimitYaw) {
+ myUpperLimitYaw = theUpperLimitYaw;
+ }
+ else myUpperLimitYaw = 0;
+
+ defLowerLimitRoll = hasLowerLimitRoll;
+ if (defLowerLimitRoll) {
+ myLowerLimitRoll = theLowerLimitRoll;
+ }
+ else myLowerLimitRoll = 0;
+
+ defUpperLimitRoll = hasUpperLimitRoll;
+ if (defUpperLimitRoll) {
+ myUpperLimitRoll = theUpperLimitRoll;
+ }
+ else myUpperLimitRoll = 0;
+}
+
+//=======================================================================
+//function : LowerLimitYaw
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_SphericalPairWithPinAndRange::LowerLimitYaw () const
+{
+ return myLowerLimitYaw;
+}
+
+//=======================================================================
+//function : SetLowerLimitYaw
+//purpose :
+//=======================================================================
+void StepKinematics_SphericalPairWithPinAndRange::SetLowerLimitYaw (const Standard_Real theLowerLimitYaw)
+{
+ myLowerLimitYaw = theLowerLimitYaw;
+}
+
+//=======================================================================
+//function : HasLowerLimitYaw
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_SphericalPairWithPinAndRange::HasLowerLimitYaw () const
+{
+ return defLowerLimitYaw;
+}
+
+//=======================================================================
+//function : UpperLimitYaw
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_SphericalPairWithPinAndRange::UpperLimitYaw () const
+{
+ return myUpperLimitYaw;
+}
+
+//=======================================================================
+//function : SetUpperLimitYaw
+//purpose :
+//=======================================================================
+void StepKinematics_SphericalPairWithPinAndRange::SetUpperLimitYaw (const Standard_Real theUpperLimitYaw)
+{
+ myUpperLimitYaw = theUpperLimitYaw;
+}
+
+//=======================================================================
+//function : HasUpperLimitYaw
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_SphericalPairWithPinAndRange::HasUpperLimitYaw () const
+{
+ return defUpperLimitYaw;
+}
+
+//=======================================================================
+//function : LowerLimitRoll
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_SphericalPairWithPinAndRange::LowerLimitRoll () const
+{
+ return myLowerLimitRoll;
+}
+
+//=======================================================================
+//function : SetLowerLimitRoll
+//purpose :
+//=======================================================================
+void StepKinematics_SphericalPairWithPinAndRange::SetLowerLimitRoll (const Standard_Real theLowerLimitRoll)
+{
+ myLowerLimitRoll = theLowerLimitRoll;
+}
+
+//=======================================================================
+//function : HasLowerLimitRoll
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_SphericalPairWithPinAndRange::HasLowerLimitRoll () const
+{
+ return defLowerLimitRoll;
+}
+
+//=======================================================================
+//function : UpperLimitRoll
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_SphericalPairWithPinAndRange::UpperLimitRoll () const
+{
+ return myUpperLimitRoll;
+}
+
+//=======================================================================
+//function : SetUpperLimitRoll
+//purpose :
+//=======================================================================
+void StepKinematics_SphericalPairWithPinAndRange::SetUpperLimitRoll (const Standard_Real theUpperLimitRoll)
+{
+ myUpperLimitRoll = theUpperLimitRoll;
+}
+
+//=======================================================================
+//function : HasUpperLimitRoll
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_SphericalPairWithPinAndRange::HasUpperLimitRoll () const
+{
+ return defUpperLimitRoll;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_SphericalPairWithPinAndRange_HeaderFile_
+#define _StepKinematics_SphericalPairWithPinAndRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_SphericalPairWithPin.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_SphericalPairWithPinAndRange, StepKinematics_SphericalPairWithPin)
+
+//! Representation of STEP entity SphericalPairWithPinAndRange
+class StepKinematics_SphericalPairWithPinAndRange : public StepKinematics_SphericalPairWithPin
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_SphericalPairWithPinAndRange();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Boolean theLowOrderKinematicPair_TX,
+ const Standard_Boolean theLowOrderKinematicPair_TY,
+ const Standard_Boolean theLowOrderKinematicPair_TZ,
+ const Standard_Boolean theLowOrderKinematicPair_RX,
+ const Standard_Boolean theLowOrderKinematicPair_RY,
+ const Standard_Boolean theLowOrderKinematicPair_RZ,
+ const Standard_Boolean hasLowerLimitYaw,
+ const Standard_Real theLowerLimitYaw,
+ const Standard_Boolean hasUpperLimitYaw,
+ const Standard_Real theUpperLimitYaw,
+ const Standard_Boolean hasLowerLimitRoll,
+ const Standard_Real theLowerLimitRoll,
+ const Standard_Boolean hasUpperLimitRoll,
+ const Standard_Real theUpperLimitRoll);
+
+ //! Returns field LowerLimitYaw
+ Standard_EXPORT Standard_Real LowerLimitYaw() const;
+ //! Sets field LowerLimitYaw
+ Standard_EXPORT void SetLowerLimitYaw (const Standard_Real theLowerLimitYaw);
+ //! Returns True if optional field LowerLimitYaw is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitYaw() const;
+
+ //! Returns field UpperLimitYaw
+ Standard_EXPORT Standard_Real UpperLimitYaw() const;
+ //! Sets field UpperLimitYaw
+ Standard_EXPORT void SetUpperLimitYaw (const Standard_Real theUpperLimitYaw);
+ //! Returns True if optional field UpperLimitYaw is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitYaw() const;
+
+ //! Returns field LowerLimitRoll
+ Standard_EXPORT Standard_Real LowerLimitRoll() const;
+ //! Sets field LowerLimitRoll
+ Standard_EXPORT void SetLowerLimitRoll (const Standard_Real theLowerLimitRoll);
+ //! Returns True if optional field LowerLimitRoll is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitRoll() const;
+
+ //! Returns field UpperLimitRoll
+ Standard_EXPORT Standard_Real UpperLimitRoll() const;
+ //! Sets field UpperLimitRoll
+ Standard_EXPORT void SetUpperLimitRoll (const Standard_Real theUpperLimitRoll);
+ //! Returns True if optional field UpperLimitRoll is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitRoll() const;
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_SphericalPairWithPinAndRange, StepKinematics_SphericalPairWithPin)
+
+private:
+ Standard_Real myLowerLimitYaw; //!< optional
+ Standard_Real myUpperLimitYaw; //!< optional
+ Standard_Real myLowerLimitRoll; //!< optional
+ Standard_Real myUpperLimitRoll; //!< optional
+ Standard_Boolean defLowerLimitYaw; //!< flag "is LowerLimitYaw defined"
+ Standard_Boolean defUpperLimitYaw; //!< flag "is UpperLimitYaw defined"
+ Standard_Boolean defLowerLimitRoll; //!< flag "is LowerLimitRoll defined"
+ Standard_Boolean defUpperLimitRoll; //!< flag "is UpperLimitRoll defined"
+
+};
+#endif // _StepKinematics_SphericalPairWithPinAndRange_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_SphericalPairWithRange.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_SphericalPairWithRange, StepKinematics_SphericalPair)
+
+//=======================================================================
+//function : StepKinematics_SphericalPairWithRange
+//purpose :
+//=======================================================================
+StepKinematics_SphericalPairWithRange::StepKinematics_SphericalPairWithRange ()
+{
+ defLowerLimitYaw = Standard_False;
+ defUpperLimitYaw = Standard_False;
+ defLowerLimitPitch = Standard_False;
+ defUpperLimitPitch = Standard_False;
+ defLowerLimitRoll = Standard_False;
+ defUpperLimitRoll = Standard_False;
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_SphericalPairWithRange::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Boolean theLowOrderKinematicPair_TX,
+ const Standard_Boolean theLowOrderKinematicPair_TY,
+ const Standard_Boolean theLowOrderKinematicPair_TZ,
+ const Standard_Boolean theLowOrderKinematicPair_RX,
+ const Standard_Boolean theLowOrderKinematicPair_RY,
+ const Standard_Boolean theLowOrderKinematicPair_RZ,
+ const Standard_Boolean hasLowerLimitYaw,
+ const Standard_Real theLowerLimitYaw,
+ const Standard_Boolean hasUpperLimitYaw,
+ const Standard_Real theUpperLimitYaw,
+ const Standard_Boolean hasLowerLimitPitch,
+ const Standard_Real theLowerLimitPitch,
+ const Standard_Boolean hasUpperLimitPitch,
+ const Standard_Real theUpperLimitPitch,
+ const Standard_Boolean hasLowerLimitRoll,
+ const Standard_Real theLowerLimitRoll,
+ const Standard_Boolean hasUpperLimitRoll,
+ const Standard_Real theUpperLimitRoll)
+{
+ StepKinematics_SphericalPair::Init(theRepresentationItem_Name,
+ theItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2,
+ theKinematicPair_Joint,
+ theLowOrderKinematicPair_TX,
+ theLowOrderKinematicPair_TY,
+ theLowOrderKinematicPair_TZ,
+ theLowOrderKinematicPair_RX,
+ theLowOrderKinematicPair_RY,
+ theLowOrderKinematicPair_RZ);
+
+ defLowerLimitYaw = hasLowerLimitYaw;
+ if (defLowerLimitYaw) {
+ myLowerLimitYaw = theLowerLimitYaw;
+ }
+ else myLowerLimitYaw = 0;
+
+ defUpperLimitYaw = hasUpperLimitYaw;
+ if (defUpperLimitYaw) {
+ myUpperLimitYaw = theUpperLimitYaw;
+ }
+ else myUpperLimitYaw = 0;
+
+ defLowerLimitPitch = hasLowerLimitPitch;
+ if (defLowerLimitPitch) {
+ myLowerLimitPitch = theLowerLimitPitch;
+ }
+ else myLowerLimitPitch = 0;
+
+ defUpperLimitPitch = hasUpperLimitPitch;
+ if (defUpperLimitPitch) {
+ myUpperLimitPitch = theUpperLimitPitch;
+ }
+ else myUpperLimitPitch = 0;
+
+ defLowerLimitRoll = hasLowerLimitRoll;
+ if (defLowerLimitRoll) {
+ myLowerLimitRoll = theLowerLimitRoll;
+ }
+ else myLowerLimitRoll = 0;
+
+ defUpperLimitRoll = hasUpperLimitRoll;
+ if (defUpperLimitRoll) {
+ myUpperLimitRoll = theUpperLimitRoll;
+ }
+ else myUpperLimitRoll = 0;
+}
+
+//=======================================================================
+//function : LowerLimitYaw
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_SphericalPairWithRange::LowerLimitYaw () const
+{
+ return myLowerLimitYaw;
+}
+
+//=======================================================================
+//function : SetLowerLimitYaw
+//purpose :
+//=======================================================================
+void StepKinematics_SphericalPairWithRange::SetLowerLimitYaw (const Standard_Real theLowerLimitYaw)
+{
+ myLowerLimitYaw = theLowerLimitYaw;
+}
+
+//=======================================================================
+//function : HasLowerLimitYaw
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_SphericalPairWithRange::HasLowerLimitYaw () const
+{
+ return defLowerLimitYaw;
+}
+
+//=======================================================================
+//function : UpperLimitYaw
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_SphericalPairWithRange::UpperLimitYaw () const
+{
+ return myUpperLimitYaw;
+}
+
+//=======================================================================
+//function : SetUpperLimitYaw
+//purpose :
+//=======================================================================
+void StepKinematics_SphericalPairWithRange::SetUpperLimitYaw (const Standard_Real theUpperLimitYaw)
+{
+ myUpperLimitYaw = theUpperLimitYaw;
+}
+
+//=======================================================================
+//function : HasUpperLimitYaw
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_SphericalPairWithRange::HasUpperLimitYaw () const
+{
+ return defUpperLimitYaw;
+}
+
+//=======================================================================
+//function : LowerLimitPitch
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_SphericalPairWithRange::LowerLimitPitch () const
+{
+ return myLowerLimitPitch;
+}
+
+//=======================================================================
+//function : SetLowerLimitPitch
+//purpose :
+//=======================================================================
+void StepKinematics_SphericalPairWithRange::SetLowerLimitPitch (const Standard_Real theLowerLimitPitch)
+{
+ myLowerLimitPitch = theLowerLimitPitch;
+}
+
+//=======================================================================
+//function : HasLowerLimitPitch
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_SphericalPairWithRange::HasLowerLimitPitch () const
+{
+ return defLowerLimitPitch;
+}
+
+//=======================================================================
+//function : UpperLimitPitch
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_SphericalPairWithRange::UpperLimitPitch () const
+{
+ return myUpperLimitPitch;
+}
+
+//=======================================================================
+//function : SetUpperLimitPitch
+//purpose :
+//=======================================================================
+void StepKinematics_SphericalPairWithRange::SetUpperLimitPitch (const Standard_Real theUpperLimitPitch)
+{
+ myUpperLimitPitch = theUpperLimitPitch;
+}
+
+//=======================================================================
+//function : HasUpperLimitPitch
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_SphericalPairWithRange::HasUpperLimitPitch () const
+{
+ return defUpperLimitPitch;
+}
+
+//=======================================================================
+//function : LowerLimitRoll
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_SphericalPairWithRange::LowerLimitRoll () const
+{
+ return myLowerLimitRoll;
+}
+
+//=======================================================================
+//function : SetLowerLimitRoll
+//purpose :
+//=======================================================================
+void StepKinematics_SphericalPairWithRange::SetLowerLimitRoll (const Standard_Real theLowerLimitRoll)
+{
+ myLowerLimitRoll = theLowerLimitRoll;
+}
+
+//=======================================================================
+//function : HasLowerLimitRoll
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_SphericalPairWithRange::HasLowerLimitRoll () const
+{
+ return defLowerLimitRoll;
+}
+
+//=======================================================================
+//function : UpperLimitRoll
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_SphericalPairWithRange::UpperLimitRoll () const
+{
+ return myUpperLimitRoll;
+}
+
+//=======================================================================
+//function : SetUpperLimitRoll
+//purpose :
+//=======================================================================
+void StepKinematics_SphericalPairWithRange::SetUpperLimitRoll (const Standard_Real theUpperLimitRoll)
+{
+ myUpperLimitRoll = theUpperLimitRoll;
+}
+
+//=======================================================================
+//function : HasUpperLimitRoll
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_SphericalPairWithRange::HasUpperLimitRoll () const
+{
+ return defUpperLimitRoll;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_SphericalPairWithRange_HeaderFile_
+#define _StepKinematics_SphericalPairWithRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_SphericalPair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_SphericalPairWithRange, StepKinematics_SphericalPair)
+
+//! Representation of STEP entity SphericalPairWithRange
+class StepKinematics_SphericalPairWithRange : public StepKinematics_SphericalPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_SphericalPairWithRange();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Boolean theLowOrderKinematicPair_TX,
+ const Standard_Boolean theLowOrderKinematicPair_TY,
+ const Standard_Boolean theLowOrderKinematicPair_TZ,
+ const Standard_Boolean theLowOrderKinematicPair_RX,
+ const Standard_Boolean theLowOrderKinematicPair_RY,
+ const Standard_Boolean theLowOrderKinematicPair_RZ,
+ const Standard_Boolean hasLowerLimitYaw,
+ const Standard_Real theLowerLimitYaw,
+ const Standard_Boolean hasUpperLimitYaw,
+ const Standard_Real theUpperLimitYaw,
+ const Standard_Boolean hasLowerLimitPitch,
+ const Standard_Real theLowerLimitPitch,
+ const Standard_Boolean hasUpperLimitPitch,
+ const Standard_Real theUpperLimitPitch,
+ const Standard_Boolean hasLowerLimitRoll,
+ const Standard_Real theLowerLimitRoll,
+ const Standard_Boolean hasUpperLimitRoll,
+ const Standard_Real theUpperLimitRoll);
+
+ //! Returns field LowerLimitYaw
+ Standard_EXPORT Standard_Real LowerLimitYaw() const;
+ //! Sets field LowerLimitYaw
+ Standard_EXPORT void SetLowerLimitYaw (const Standard_Real theLowerLimitYaw);
+ //! Returns True if optional field LowerLimitYaw is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitYaw() const;
+
+ //! Returns field UpperLimitYaw
+ Standard_EXPORT Standard_Real UpperLimitYaw() const;
+ //! Sets field UpperLimitYaw
+ Standard_EXPORT void SetUpperLimitYaw (const Standard_Real theUpperLimitYaw);
+ //! Returns True if optional field UpperLimitYaw is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitYaw() const;
+
+ //! Returns field LowerLimitPitch
+ Standard_EXPORT Standard_Real LowerLimitPitch() const;
+ //! Sets field LowerLimitPitch
+ Standard_EXPORT void SetLowerLimitPitch (const Standard_Real theLowerLimitPitch);
+ //! Returns True if optional field LowerLimitPitch is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitPitch() const;
+
+ //! Returns field UpperLimitPitch
+ Standard_EXPORT Standard_Real UpperLimitPitch() const;
+ //! Sets field UpperLimitPitch
+ Standard_EXPORT void SetUpperLimitPitch (const Standard_Real theUpperLimitPitch);
+ //! Returns True if optional field UpperLimitPitch is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitPitch() const;
+
+ //! Returns field LowerLimitRoll
+ Standard_EXPORT Standard_Real LowerLimitRoll() const;
+ //! Sets field LowerLimitRoll
+ Standard_EXPORT void SetLowerLimitRoll (const Standard_Real theLowerLimitRoll);
+ //! Returns True if optional field LowerLimitRoll is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitRoll() const;
+
+ //! Returns field UpperLimitRoll
+ Standard_EXPORT Standard_Real UpperLimitRoll() const;
+ //! Sets field UpperLimitRoll
+ Standard_EXPORT void SetUpperLimitRoll (const Standard_Real theUpperLimitRoll);
+ //! Returns True if optional field UpperLimitRoll is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitRoll() const;
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_SphericalPairWithRange, StepKinematics_SphericalPair)
+
+private:
+ Standard_Real myLowerLimitYaw; //!< optional
+ Standard_Real myUpperLimitYaw; //!< optional
+ Standard_Real myLowerLimitPitch; //!< optional
+ Standard_Real myUpperLimitPitch; //!< optional
+ Standard_Real myLowerLimitRoll; //!< optional
+ Standard_Real myUpperLimitRoll; //!< optional
+ Standard_Boolean defLowerLimitYaw; //!< flag "is LowerLimitYaw defined"
+ Standard_Boolean defUpperLimitYaw; //!< flag "is UpperLimitYaw defined"
+ Standard_Boolean defLowerLimitPitch; //!< flag "is LowerLimitPitch defined"
+ Standard_Boolean defUpperLimitPitch; //!< flag "is UpperLimitPitch defined"
+ Standard_Boolean defLowerLimitRoll; //!< flag "is LowerLimitRoll defined"
+ Standard_Boolean defUpperLimitRoll; //!< flag "is UpperLimitRoll defined"
+
+};
+#endif // _StepKinematics_SphericalPairWithRange_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_SurfacePair.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_SurfacePair, StepKinematics_HighOrderKinematicPair)
+
+//=======================================================================
+//function : StepKinematics_SurfacePair
+//purpose :
+//=======================================================================
+StepKinematics_SurfacePair::StepKinematics_SurfacePair ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_SurfacePair::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Handle(StepGeom_Surface)& theSurface1,
+ const Handle(StepGeom_Surface)& theSurface2,
+ const Standard_Boolean theOrientation)
+{
+ StepKinematics_HighOrderKinematicPair::Init(theRepresentationItem_Name,
+ theItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2,
+ theKinematicPair_Joint);
+
+ mySurface1 = theSurface1;
+
+ mySurface2 = theSurface2;
+
+ myOrientation = theOrientation;
+}
+
+//=======================================================================
+//function : Surface1
+//purpose :
+//=======================================================================
+Handle(StepGeom_Surface) StepKinematics_SurfacePair::Surface1 () const
+{
+ return mySurface1;
+}
+
+//=======================================================================
+//function : SetSurface1
+//purpose :
+//=======================================================================
+void StepKinematics_SurfacePair::SetSurface1 (const Handle(StepGeom_Surface)& theSurface1)
+{
+ mySurface1 = theSurface1;
+}
+
+//=======================================================================
+//function : Surface2
+//purpose :
+//=======================================================================
+Handle(StepGeom_Surface) StepKinematics_SurfacePair::Surface2 () const
+{
+ return mySurface2;
+}
+
+//=======================================================================
+//function : SetSurface2
+//purpose :
+//=======================================================================
+void StepKinematics_SurfacePair::SetSurface2 (const Handle(StepGeom_Surface)& theSurface2)
+{
+ mySurface2 = theSurface2;
+}
+
+//=======================================================================
+//function : Orientation
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_SurfacePair::Orientation () const
+{
+ return myOrientation;
+}
+
+//=======================================================================
+//function : SetOrientation
+//purpose :
+//=======================================================================
+void StepKinematics_SurfacePair::SetOrientation (const Standard_Boolean theOrientation)
+{
+ myOrientation = theOrientation;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_SurfacePair_HeaderFile_
+#define _StepKinematics_SurfacePair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_HighOrderKinematicPair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Surface.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_SurfacePair, StepKinematics_HighOrderKinematicPair)
+
+//! Representation of STEP entity SurfacePair
+class StepKinematics_SurfacePair : public StepKinematics_HighOrderKinematicPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_SurfacePair();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Handle(StepGeom_Surface)& theSurface1,
+ const Handle(StepGeom_Surface)& theSurface2,
+ const Standard_Boolean theOrientation);
+
+ //! Returns field Surface1
+ Standard_EXPORT Handle(StepGeom_Surface) Surface1() const;
+ //! Sets field Surface1
+ Standard_EXPORT void SetSurface1 (const Handle(StepGeom_Surface)& theSurface1);
+
+ //! Returns field Surface2
+ Standard_EXPORT Handle(StepGeom_Surface) Surface2() const;
+ //! Sets field Surface2
+ Standard_EXPORT void SetSurface2 (const Handle(StepGeom_Surface)& theSurface2);
+
+ //! Returns field Orientation
+ Standard_EXPORT Standard_Boolean Orientation() const;
+ //! Sets field Orientation
+ Standard_EXPORT void SetOrientation (const Standard_Boolean theOrientation);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_SurfacePair, StepKinematics_HighOrderKinematicPair)
+
+private:
+ Handle(StepGeom_Surface) mySurface1;
+ Handle(StepGeom_Surface) mySurface2;
+ Standard_Boolean myOrientation;
+
+};
+#endif // _StepKinematics_SurfacePair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_SurfacePairWithRange.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_SurfacePairWithRange, StepKinematics_SurfacePair)
+
+//=======================================================================
+//function : StepKinematics_SurfacePairWithRange
+//purpose :
+//=======================================================================
+StepKinematics_SurfacePairWithRange::StepKinematics_SurfacePairWithRange ()
+{
+ defLowerLimitActualRotation = Standard_False;
+ defUpperLimitActualRotation = Standard_False;
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_SurfacePairWithRange::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Handle(StepGeom_Surface)& theSurfacePair_Surface1,
+ const Handle(StepGeom_Surface)& theSurfacePair_Surface2,
+ const Standard_Boolean theSurfacePair_Orientation,
+ const Handle(StepGeom_RectangularTrimmedSurface)& theRangeOnSurface1,
+ const Handle(StepGeom_RectangularTrimmedSurface)& theRangeOnSurface2,
+ const Standard_Boolean hasLowerLimitActualRotation,
+ const Standard_Real theLowerLimitActualRotation,
+ const Standard_Boolean hasUpperLimitActualRotation,
+ const Standard_Real theUpperLimitActualRotation)
+{
+ StepKinematics_SurfacePair::Init(theRepresentationItem_Name,
+ theItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2,
+ theKinematicPair_Joint,
+ theSurfacePair_Surface1,
+ theSurfacePair_Surface2,
+ theSurfacePair_Orientation);
+
+ myRangeOnSurface1 = theRangeOnSurface1;
+
+ myRangeOnSurface2 = theRangeOnSurface2;
+
+ defLowerLimitActualRotation = hasLowerLimitActualRotation;
+ if (defLowerLimitActualRotation) {
+ myLowerLimitActualRotation = theLowerLimitActualRotation;
+ }
+ else myLowerLimitActualRotation = 0;
+
+ defUpperLimitActualRotation = hasUpperLimitActualRotation;
+ if (defUpperLimitActualRotation) {
+ myUpperLimitActualRotation = theUpperLimitActualRotation;
+ }
+ else myUpperLimitActualRotation = 0;
+}
+
+//=======================================================================
+//function : RangeOnSurface1
+//purpose :
+//=======================================================================
+Handle(StepGeom_RectangularTrimmedSurface) StepKinematics_SurfacePairWithRange::RangeOnSurface1 () const
+{
+ return myRangeOnSurface1;
+}
+
+//=======================================================================
+//function : SetRangeOnSurface1
+//purpose :
+//=======================================================================
+void StepKinematics_SurfacePairWithRange::SetRangeOnSurface1 (const Handle(StepGeom_RectangularTrimmedSurface)& theRangeOnSurface1)
+{
+ myRangeOnSurface1 = theRangeOnSurface1;
+}
+
+//=======================================================================
+//function : RangeOnSurface2
+//purpose :
+//=======================================================================
+Handle(StepGeom_RectangularTrimmedSurface) StepKinematics_SurfacePairWithRange::RangeOnSurface2 () const
+{
+ return myRangeOnSurface2;
+}
+
+//=======================================================================
+//function : SetRangeOnSurface2
+//purpose :
+//=======================================================================
+void StepKinematics_SurfacePairWithRange::SetRangeOnSurface2 (const Handle(StepGeom_RectangularTrimmedSurface)& theRangeOnSurface2)
+{
+ myRangeOnSurface2 = theRangeOnSurface2;
+}
+
+//=======================================================================
+//function : LowerLimitActualRotation
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_SurfacePairWithRange::LowerLimitActualRotation () const
+{
+ return myLowerLimitActualRotation;
+}
+
+//=======================================================================
+//function : SetLowerLimitActualRotation
+//purpose :
+//=======================================================================
+void StepKinematics_SurfacePairWithRange::SetLowerLimitActualRotation (const Standard_Real theLowerLimitActualRotation)
+{
+ myLowerLimitActualRotation = theLowerLimitActualRotation;
+}
+
+//=======================================================================
+//function : HasLowerLimitActualRotation
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_SurfacePairWithRange::HasLowerLimitActualRotation () const
+{
+ return defLowerLimitActualRotation;
+}
+
+//=======================================================================
+//function : UpperLimitActualRotation
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_SurfacePairWithRange::UpperLimitActualRotation () const
+{
+ return myUpperLimitActualRotation;
+}
+
+//=======================================================================
+//function : SetUpperLimitActualRotation
+//purpose :
+//=======================================================================
+void StepKinematics_SurfacePairWithRange::SetUpperLimitActualRotation (const Standard_Real theUpperLimitActualRotation)
+{
+ myUpperLimitActualRotation = theUpperLimitActualRotation;
+}
+
+//=======================================================================
+//function : HasUpperLimitActualRotation
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_SurfacePairWithRange::HasUpperLimitActualRotation () const
+{
+ return defUpperLimitActualRotation;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_SurfacePairWithRange_HeaderFile_
+#define _StepKinematics_SurfacePairWithRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_SurfacePair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Surface.hxx>
+#include <StepGeom_RectangularTrimmedSurface.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_SurfacePairWithRange, StepKinematics_SurfacePair)
+
+//! Representation of STEP entity SurfacePairWithRange
+class StepKinematics_SurfacePairWithRange : public StepKinematics_SurfacePair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_SurfacePairWithRange();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Handle(StepGeom_Surface)& theSurfacePair_Surface1,
+ const Handle(StepGeom_Surface)& theSurfacePair_Surface2,
+ const Standard_Boolean theSurfacePair_Orientation,
+ const Handle(StepGeom_RectangularTrimmedSurface)& theRangeOnSurface1,
+ const Handle(StepGeom_RectangularTrimmedSurface)& theRangeOnSurface2,
+ const Standard_Boolean hasLowerLimitActualRotation,
+ const Standard_Real theLowerLimitActualRotation,
+ const Standard_Boolean hasUpperLimitActualRotation,
+ const Standard_Real theUpperLimitActualRotation);
+
+ //! Returns field RangeOnSurface1
+ Standard_EXPORT Handle(StepGeom_RectangularTrimmedSurface) RangeOnSurface1() const;
+ //! Sets field RangeOnSurface1
+ Standard_EXPORT void SetRangeOnSurface1 (const Handle(StepGeom_RectangularTrimmedSurface)& theRangeOnSurface1);
+
+ //! Returns field RangeOnSurface2
+ Standard_EXPORT Handle(StepGeom_RectangularTrimmedSurface) RangeOnSurface2() const;
+ //! Sets field RangeOnSurface2
+ Standard_EXPORT void SetRangeOnSurface2 (const Handle(StepGeom_RectangularTrimmedSurface)& theRangeOnSurface2);
+
+ //! Returns field LowerLimitActualRotation
+ Standard_EXPORT Standard_Real LowerLimitActualRotation() const;
+ //! Sets field LowerLimitActualRotation
+ Standard_EXPORT void SetLowerLimitActualRotation (const Standard_Real theLowerLimitActualRotation);
+ //! Returns True if optional field LowerLimitActualRotation is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitActualRotation() const;
+
+ //! Returns field UpperLimitActualRotation
+ Standard_EXPORT Standard_Real UpperLimitActualRotation() const;
+ //! Sets field UpperLimitActualRotation
+ Standard_EXPORT void SetUpperLimitActualRotation (const Standard_Real theUpperLimitActualRotation);
+ //! Returns True if optional field UpperLimitActualRotation is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitActualRotation() const;
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_SurfacePairWithRange, StepKinematics_SurfacePair)
+
+private:
+ Handle(StepGeom_RectangularTrimmedSurface) myRangeOnSurface1;
+ Handle(StepGeom_RectangularTrimmedSurface) myRangeOnSurface2;
+ Standard_Real myLowerLimitActualRotation; //!< optional
+ Standard_Real myUpperLimitActualRotation; //!< optional
+ Standard_Boolean defLowerLimitActualRotation; //!< flag "is LowerLimitActualRotation defined"
+ Standard_Boolean defUpperLimitActualRotation; //!< flag "is UpperLimitActualRotation defined"
+
+};
+#endif // _StepKinematics_SurfacePairWithRange_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_UnconstrainedPair.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_UnconstrainedPair, StepKinematics_LowOrderKinematicPair)
+
+//=======================================================================
+//function : StepKinematics_UnconstrainedPair
+//purpose :
+//=======================================================================
+StepKinematics_UnconstrainedPair::StepKinematics_UnconstrainedPair ()
+{
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_UnconstrainedPair_HeaderFile_
+#define _StepKinematics_UnconstrainedPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_LowOrderKinematicPair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_UnconstrainedPair, StepKinematics_LowOrderKinematicPair)
+
+//! Representation of STEP entity UnconstrainedPair
+class StepKinematics_UnconstrainedPair : public StepKinematics_LowOrderKinematicPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_UnconstrainedPair();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_UnconstrainedPair, StepKinematics_LowOrderKinematicPair)
+
+};
+#endif // _StepKinematics_UnconstrainedPair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_UnconstrainedPairValue.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_UnconstrainedPairValue, StepKinematics_PairValue)
+
+//=======================================================================
+//function : StepKinematics_UnconstrainedPairValue
+//purpose :
+//=======================================================================
+StepKinematics_UnconstrainedPairValue::StepKinematics_UnconstrainedPairValue ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_UnconstrainedPairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Handle(StepGeom_Axis2Placement3d)& theActualPlacement)
+{
+ StepKinematics_PairValue::Init(theRepresentationItem_Name,
+ thePairValue_AppliesToPair);
+
+ myActualPlacement = theActualPlacement;
+}
+
+//=======================================================================
+//function : ActualPlacement
+//purpose :
+//=======================================================================
+Handle(StepGeom_Axis2Placement3d) StepKinematics_UnconstrainedPairValue::ActualPlacement () const
+{
+ return myActualPlacement;
+}
+
+//=======================================================================
+//function : SetActualPlacement
+//purpose :
+//=======================================================================
+void StepKinematics_UnconstrainedPairValue::SetActualPlacement (const Handle(StepGeom_Axis2Placement3d)& theActualPlacement)
+{
+ myActualPlacement = theActualPlacement;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_UnconstrainedPairValue_HeaderFile_
+#define _StepKinematics_UnconstrainedPairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_PairValue.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <StepGeom_Axis2Placement3d.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_UnconstrainedPairValue, StepKinematics_PairValue)
+
+//! Representation of STEP entity UnconstrainedPairValue
+class StepKinematics_UnconstrainedPairValue : public StepKinematics_PairValue
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_UnconstrainedPairValue();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Handle(StepGeom_Axis2Placement3d)& theActualPlacement);
+
+ //! Returns field ActualPlacement
+ Standard_EXPORT Handle(StepGeom_Axis2Placement3d) ActualPlacement() const;
+ //! Sets field ActualPlacement
+ Standard_EXPORT void SetActualPlacement (const Handle(StepGeom_Axis2Placement3d)& theActualPlacement);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_UnconstrainedPairValue, StepKinematics_PairValue)
+
+private:
+ Handle(StepGeom_Axis2Placement3d) myActualPlacement;
+
+};
+#endif // _StepKinematics_UnconstrainedPairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_UniversalPair.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_UniversalPair, StepKinematics_LowOrderKinematicPair)
+
+//=======================================================================
+//function : StepKinematics_UniversalPair
+//purpose :
+//=======================================================================
+StepKinematics_UniversalPair::StepKinematics_UniversalPair ()
+{
+ defInputSkewAngle = Standard_False;
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_UniversalPair::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Boolean theLowOrderKinematicPair_TX,
+ const Standard_Boolean theLowOrderKinematicPair_TY,
+ const Standard_Boolean theLowOrderKinematicPair_TZ,
+ const Standard_Boolean theLowOrderKinematicPair_RX,
+ const Standard_Boolean theLowOrderKinematicPair_RY,
+ const Standard_Boolean theLowOrderKinematicPair_RZ,
+ const Standard_Boolean hasInputSkewAngle,
+ const Standard_Real theInputSkewAngle)
+{
+ StepKinematics_LowOrderKinematicPair::Init(theRepresentationItem_Name,
+ theItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2,
+ theKinematicPair_Joint,
+ theLowOrderKinematicPair_TX,
+ theLowOrderKinematicPair_TY,
+ theLowOrderKinematicPair_TZ,
+ theLowOrderKinematicPair_RX,
+ theLowOrderKinematicPair_RY,
+ theLowOrderKinematicPair_RZ);
+
+ defInputSkewAngle = hasInputSkewAngle;
+ if (defInputSkewAngle) {
+ myInputSkewAngle = theInputSkewAngle;
+ }
+ else myInputSkewAngle = 0;
+}
+
+//=======================================================================
+//function : InputSkewAngle
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_UniversalPair::InputSkewAngle () const
+{
+ return myInputSkewAngle;
+}
+
+//=======================================================================
+//function : SetInputSkewAngle
+//purpose :
+//=======================================================================
+void StepKinematics_UniversalPair::SetInputSkewAngle (const Standard_Real theInputSkewAngle)
+{
+ myInputSkewAngle = theInputSkewAngle;
+}
+
+//=======================================================================
+//function : HasInputSkewAngle
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_UniversalPair::HasInputSkewAngle () const
+{
+ return defInputSkewAngle;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_UniversalPair_HeaderFile_
+#define _StepKinematics_UniversalPair_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_LowOrderKinematicPair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_UniversalPair, StepKinematics_LowOrderKinematicPair)
+
+//! Representation of STEP entity UniversalPair
+class StepKinematics_UniversalPair : public StepKinematics_LowOrderKinematicPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_UniversalPair();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Boolean theLowOrderKinematicPair_TX,
+ const Standard_Boolean theLowOrderKinematicPair_TY,
+ const Standard_Boolean theLowOrderKinematicPair_TZ,
+ const Standard_Boolean theLowOrderKinematicPair_RX,
+ const Standard_Boolean theLowOrderKinematicPair_RY,
+ const Standard_Boolean theLowOrderKinematicPair_RZ,
+ const Standard_Boolean hasInputSkewAngle,
+ const Standard_Real theInputSkewAngle);
+
+ //! Returns field InputSkewAngle
+ Standard_EXPORT Standard_Real InputSkewAngle() const;
+ //! Sets field InputSkewAngle
+ Standard_EXPORT void SetInputSkewAngle (const Standard_Real theInputSkewAngle);
+ //! Returns True if optional field InputSkewAngle is defined
+ Standard_EXPORT Standard_Boolean HasInputSkewAngle() const;
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_UniversalPair, StepKinematics_LowOrderKinematicPair)
+
+private:
+ Standard_Real myInputSkewAngle; //!< optional
+ Standard_Boolean defInputSkewAngle; //!< flag "is InputSkewAngle defined"
+
+};
+#endif // _StepKinematics_UniversalPair_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_UniversalPairValue.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_UniversalPairValue, StepKinematics_PairValue)
+
+//=======================================================================
+//function : StepKinematics_UniversalPairValue
+//purpose :
+//=======================================================================
+StepKinematics_UniversalPairValue::StepKinematics_UniversalPairValue ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_UniversalPairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Standard_Real theFirstRotationAngle,
+ const Standard_Real theSecondRotationAngle)
+{
+ StepKinematics_PairValue::Init(theRepresentationItem_Name,
+ thePairValue_AppliesToPair);
+
+ myFirstRotationAngle = theFirstRotationAngle;
+
+ mySecondRotationAngle = theSecondRotationAngle;
+}
+
+//=======================================================================
+//function : FirstRotationAngle
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_UniversalPairValue::FirstRotationAngle () const
+{
+ return myFirstRotationAngle;
+}
+
+//=======================================================================
+//function : SetFirstRotationAngle
+//purpose :
+//=======================================================================
+void StepKinematics_UniversalPairValue::SetFirstRotationAngle (const Standard_Real theFirstRotationAngle)
+{
+ myFirstRotationAngle = theFirstRotationAngle;
+}
+
+//=======================================================================
+//function : SecondRotationAngle
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_UniversalPairValue::SecondRotationAngle () const
+{
+ return mySecondRotationAngle;
+}
+
+//=======================================================================
+//function : SetSecondRotationAngle
+//purpose :
+//=======================================================================
+void StepKinematics_UniversalPairValue::SetSecondRotationAngle (const Standard_Real theSecondRotationAngle)
+{
+ mySecondRotationAngle = theSecondRotationAngle;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_UniversalPairValue_HeaderFile_
+#define _StepKinematics_UniversalPairValue_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_PairValue.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_UniversalPairValue, StepKinematics_PairValue)
+
+//! Representation of STEP entity UniversalPairValue
+class StepKinematics_UniversalPairValue : public StepKinematics_PairValue
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_UniversalPairValue();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair,
+ const Standard_Real theFirstRotationAngle,
+ const Standard_Real theSecondRotationAngle);
+
+ //! Returns field FirstRotationAngle
+ Standard_EXPORT Standard_Real FirstRotationAngle() const;
+ //! Sets field FirstRotationAngle
+ Standard_EXPORT void SetFirstRotationAngle (const Standard_Real theFirstRotationAngle);
+
+ //! Returns field SecondRotationAngle
+ Standard_EXPORT Standard_Real SecondRotationAngle() const;
+ //! Sets field SecondRotationAngle
+ Standard_EXPORT void SetSecondRotationAngle (const Standard_Real theSecondRotationAngle);
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_UniversalPairValue, StepKinematics_PairValue)
+
+private:
+ Standard_Real myFirstRotationAngle;
+ Standard_Real mySecondRotationAngle;
+
+};
+#endif // _StepKinematics_UniversalPairValue_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepKinematics_UniversalPairWithRange.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_UniversalPairWithRange, StepKinematics_UniversalPair)
+
+//=======================================================================
+//function : StepKinematics_UniversalPairWithRange
+//purpose :
+//=======================================================================
+StepKinematics_UniversalPairWithRange::StepKinematics_UniversalPairWithRange ()
+{
+ defLowerLimitFirstRotation = Standard_False;
+ defUpperLimitFirstRotation = Standard_False;
+ defLowerLimitSecondRotation = Standard_False;
+ defUpperLimitSecondRotation = Standard_False;
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepKinematics_UniversalPairWithRange::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Boolean theLowOrderKinematicPair_TX,
+ const Standard_Boolean theLowOrderKinematicPair_TY,
+ const Standard_Boolean theLowOrderKinematicPair_TZ,
+ const Standard_Boolean theLowOrderKinematicPair_RX,
+ const Standard_Boolean theLowOrderKinematicPair_RY,
+ const Standard_Boolean theLowOrderKinematicPair_RZ,
+ const Standard_Boolean hasUniversalPair_InputSkewAngle,
+ const Standard_Real theUniversalPair_InputSkewAngle,
+ const Standard_Boolean hasLowerLimitFirstRotation,
+ const Standard_Real theLowerLimitFirstRotation,
+ const Standard_Boolean hasUpperLimitFirstRotation,
+ const Standard_Real theUpperLimitFirstRotation,
+ const Standard_Boolean hasLowerLimitSecondRotation,
+ const Standard_Real theLowerLimitSecondRotation,
+ const Standard_Boolean hasUpperLimitSecondRotation,
+ const Standard_Real theUpperLimitSecondRotation)
+{
+ StepKinematics_UniversalPair::Init(theRepresentationItem_Name,
+ theItemDefinedTransformation_Name,
+ hasItemDefinedTransformation_Description,
+ theItemDefinedTransformation_Description,
+ theItemDefinedTransformation_TransformItem1,
+ theItemDefinedTransformation_TransformItem2,
+ theKinematicPair_Joint,
+ theLowOrderKinematicPair_TX,
+ theLowOrderKinematicPair_TY,
+ theLowOrderKinematicPair_TZ,
+ theLowOrderKinematicPair_RX,
+ theLowOrderKinematicPair_RY,
+ theLowOrderKinematicPair_RZ,
+ hasUniversalPair_InputSkewAngle,
+ theUniversalPair_InputSkewAngle);
+
+ defLowerLimitFirstRotation = hasLowerLimitFirstRotation;
+ if (defLowerLimitFirstRotation) {
+ myLowerLimitFirstRotation = theLowerLimitFirstRotation;
+ }
+ else myLowerLimitFirstRotation = 0;
+
+ defUpperLimitFirstRotation = hasUpperLimitFirstRotation;
+ if (defUpperLimitFirstRotation) {
+ myUpperLimitFirstRotation = theUpperLimitFirstRotation;
+ }
+ else myUpperLimitFirstRotation = 0;
+
+ defLowerLimitSecondRotation = hasLowerLimitSecondRotation;
+ if (defLowerLimitSecondRotation) {
+ myLowerLimitSecondRotation = theLowerLimitSecondRotation;
+ }
+ else myLowerLimitSecondRotation = 0;
+
+ defUpperLimitSecondRotation = hasUpperLimitSecondRotation;
+ if (defUpperLimitSecondRotation) {
+ myUpperLimitSecondRotation = theUpperLimitSecondRotation;
+ }
+ else myUpperLimitSecondRotation = 0;
+}
+
+//=======================================================================
+//function : LowerLimitFirstRotation
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_UniversalPairWithRange::LowerLimitFirstRotation () const
+{
+ return myLowerLimitFirstRotation;
+}
+
+//=======================================================================
+//function : SetLowerLimitFirstRotation
+//purpose :
+//=======================================================================
+void StepKinematics_UniversalPairWithRange::SetLowerLimitFirstRotation (const Standard_Real theLowerLimitFirstRotation)
+{
+ myLowerLimitFirstRotation = theLowerLimitFirstRotation;
+}
+
+//=======================================================================
+//function : HasLowerLimitFirstRotation
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_UniversalPairWithRange::HasLowerLimitFirstRotation () const
+{
+ return defLowerLimitFirstRotation;
+}
+
+//=======================================================================
+//function : UpperLimitFirstRotation
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_UniversalPairWithRange::UpperLimitFirstRotation () const
+{
+ return myUpperLimitFirstRotation;
+}
+
+//=======================================================================
+//function : SetUpperLimitFirstRotation
+//purpose :
+//=======================================================================
+void StepKinematics_UniversalPairWithRange::SetUpperLimitFirstRotation (const Standard_Real theUpperLimitFirstRotation)
+{
+ myUpperLimitFirstRotation = theUpperLimitFirstRotation;
+}
+
+//=======================================================================
+//function : HasUpperLimitFirstRotation
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_UniversalPairWithRange::HasUpperLimitFirstRotation () const
+{
+ return defUpperLimitFirstRotation;
+}
+
+//=======================================================================
+//function : LowerLimitSecondRotation
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_UniversalPairWithRange::LowerLimitSecondRotation () const
+{
+ return myLowerLimitSecondRotation;
+}
+
+//=======================================================================
+//function : SetLowerLimitSecondRotation
+//purpose :
+//=======================================================================
+void StepKinematics_UniversalPairWithRange::SetLowerLimitSecondRotation (const Standard_Real theLowerLimitSecondRotation)
+{
+ myLowerLimitSecondRotation = theLowerLimitSecondRotation;
+}
+
+//=======================================================================
+//function : HasLowerLimitSecondRotation
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_UniversalPairWithRange::HasLowerLimitSecondRotation () const
+{
+ return defLowerLimitSecondRotation;
+}
+
+//=======================================================================
+//function : UpperLimitSecondRotation
+//purpose :
+//=======================================================================
+Standard_Real StepKinematics_UniversalPairWithRange::UpperLimitSecondRotation () const
+{
+ return myUpperLimitSecondRotation;
+}
+
+//=======================================================================
+//function : SetUpperLimitSecondRotation
+//purpose :
+//=======================================================================
+void StepKinematics_UniversalPairWithRange::SetUpperLimitSecondRotation (const Standard_Real theUpperLimitSecondRotation)
+{
+ myUpperLimitSecondRotation = theUpperLimitSecondRotation;
+}
+
+//=======================================================================
+//function : HasUpperLimitSecondRotation
+//purpose :
+//=======================================================================
+Standard_Boolean StepKinematics_UniversalPairWithRange::HasUpperLimitSecondRotation () const
+{
+ return defUpperLimitSecondRotation;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:16 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepKinematics_UniversalPairWithRange_HeaderFile_
+#define _StepKinematics_UniversalPairWithRange_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepKinematics_UniversalPair.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_UniversalPairWithRange, StepKinematics_UniversalPair)
+
+//! Representation of STEP entity UniversalPairWithRange
+class StepKinematics_UniversalPairWithRange : public StepKinematics_UniversalPair
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_UniversalPairWithRange();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name,
+ const Standard_Boolean hasItemDefinedTransformation_Description,
+ const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1,
+ const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2,
+ const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint,
+ const Standard_Boolean theLowOrderKinematicPair_TX,
+ const Standard_Boolean theLowOrderKinematicPair_TY,
+ const Standard_Boolean theLowOrderKinematicPair_TZ,
+ const Standard_Boolean theLowOrderKinematicPair_RX,
+ const Standard_Boolean theLowOrderKinematicPair_RY,
+ const Standard_Boolean theLowOrderKinematicPair_RZ,
+ const Standard_Boolean hasUniversalPair_InputSkewAngle,
+ const Standard_Real theUniversalPair_InputSkewAngle,
+ const Standard_Boolean hasLowerLimitFirstRotation,
+ const Standard_Real theLowerLimitFirstRotation,
+ const Standard_Boolean hasUpperLimitFirstRotation,
+ const Standard_Real theUpperLimitFirstRotation,
+ const Standard_Boolean hasLowerLimitSecondRotation,
+ const Standard_Real theLowerLimitSecondRotation,
+ const Standard_Boolean hasUpperLimitSecondRotation,
+ const Standard_Real theUpperLimitSecondRotation);
+
+ //! Returns field LowerLimitFirstRotation
+ Standard_EXPORT Standard_Real LowerLimitFirstRotation() const;
+ //! Sets field LowerLimitFirstRotation
+ Standard_EXPORT void SetLowerLimitFirstRotation (const Standard_Real theLowerLimitFirstRotation);
+ //! Returns True if optional field LowerLimitFirstRotation is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitFirstRotation() const;
+
+ //! Returns field UpperLimitFirstRotation
+ Standard_EXPORT Standard_Real UpperLimitFirstRotation() const;
+ //! Sets field UpperLimitFirstRotation
+ Standard_EXPORT void SetUpperLimitFirstRotation (const Standard_Real theUpperLimitFirstRotation);
+ //! Returns True if optional field UpperLimitFirstRotation is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitFirstRotation() const;
+
+ //! Returns field LowerLimitSecondRotation
+ Standard_EXPORT Standard_Real LowerLimitSecondRotation() const;
+ //! Sets field LowerLimitSecondRotation
+ Standard_EXPORT void SetLowerLimitSecondRotation (const Standard_Real theLowerLimitSecondRotation);
+ //! Returns True if optional field LowerLimitSecondRotation is defined
+ Standard_EXPORT Standard_Boolean HasLowerLimitSecondRotation() const;
+
+ //! Returns field UpperLimitSecondRotation
+ Standard_EXPORT Standard_Real UpperLimitSecondRotation() const;
+ //! Sets field UpperLimitSecondRotation
+ Standard_EXPORT void SetUpperLimitSecondRotation (const Standard_Real theUpperLimitSecondRotation);
+ //! Returns True if optional field UpperLimitSecondRotation is defined
+ Standard_EXPORT Standard_Boolean HasUpperLimitSecondRotation() const;
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_UniversalPairWithRange, StepKinematics_UniversalPair)
+
+private:
+ Standard_Real myLowerLimitFirstRotation; //!< optional
+ Standard_Real myUpperLimitFirstRotation; //!< optional
+ Standard_Real myLowerLimitSecondRotation; //!< optional
+ Standard_Real myUpperLimitSecondRotation; //!< optional
+ Standard_Boolean defLowerLimitFirstRotation; //!< flag "is LowerLimitFirstRotation defined"
+ Standard_Boolean defUpperLimitFirstRotation; //!< flag "is UpperLimitFirstRotation defined"
+ Standard_Boolean defLowerLimitSecondRotation; //!< flag "is LowerLimitSecondRotation defined"
+ Standard_Boolean defUpperLimitSecondRotation; //!< flag "is UpperLimitSecondRotation defined"
+
+};
+#endif // _StepKinematics_UniversalPairWithRange_HeaderFile_
StepRepr_Representation.hxx
StepRepr_RepresentationContext.cxx
StepRepr_RepresentationContext.hxx
+StepRepr_RepresentationContextReference.cxx
+StepRepr_RepresentationContextReference.hxx
StepRepr_RepresentationItem.cxx
StepRepr_RepresentationItem.hxx
StepRepr_RepresentationMap.cxx
StepRepr_RepresentationMap.hxx
+StepRepr_RepresentationOrRepresentationReference.cxx
+StepRepr_RepresentationOrRepresentationReference.hxx
+StepRepr_RepresentationReference.cxx
+StepRepr_RepresentationReference.hxx
StepRepr_RepresentationRelationship.cxx
StepRepr_RepresentationRelationship.hxx
StepRepr_RepresentationRelationshipWithTransformation.cxx
Standard_EXPORT void SetName (const Handle(TCollection_HAsciiString)& aName);
Standard_EXPORT Handle(TCollection_HAsciiString) Name() const;
+
+ Standard_Boolean HasDescription() const { return !theDescription.IsNull(); }
Standard_EXPORT void SetDescription (const Handle(TCollection_HAsciiString)& aDescription);
--- /dev/null
+// Created on : Sat May 02 12:41:14 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepRepr_RepresentationContextReference.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepRepr_RepresentationContextReference, Standard_Transient)
+
+//=======================================================================
+//function : StepRepr_RepresentationContextReference
+//purpose :
+//=======================================================================
+
+StepRepr_RepresentationContextReference::StepRepr_RepresentationContextReference ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepRepr_RepresentationContextReference::Init (const Handle(TCollection_HAsciiString)& theContextIdentifier)
+{
+
+ myContextIdentifier = theContextIdentifier;
+}
+
+//=======================================================================
+//function : ContextIdentifier
+//purpose :
+//=======================================================================
+
+Handle(TCollection_HAsciiString) StepRepr_RepresentationContextReference::ContextIdentifier () const
+{
+ return myContextIdentifier;
+}
+
+//=======================================================================
+//function : SetContextIdentifier
+//purpose :
+//=======================================================================
+
+void StepRepr_RepresentationContextReference::SetContextIdentifier (const Handle(TCollection_HAsciiString)& theContextIdentifier)
+{
+ myContextIdentifier = theContextIdentifier;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:14 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepRepr_RepresentationContextReference_HeaderFile_
+#define _StepRepr_RepresentationContextReference_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <Standard_Transient.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+
+DEFINE_STANDARD_HANDLE(StepRepr_RepresentationContextReference, Standard_Transient)
+
+//! Representation of STEP entity RepresentationContextReference
+class StepRepr_RepresentationContextReference : public Standard_Transient
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepRepr_RepresentationContextReference();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theContextIdentifier);
+
+ //! Returns field ContextIdentifier
+ Standard_EXPORT Handle(TCollection_HAsciiString) ContextIdentifier() const;
+ //! Sets field ContextIdentifier
+ Standard_EXPORT void SetContextIdentifier (const Handle(TCollection_HAsciiString)& theContextIdentifier);
+
+DEFINE_STANDARD_RTTIEXT(StepRepr_RepresentationContextReference, Standard_Transient)
+
+private:
+ Handle(TCollection_HAsciiString) myContextIdentifier;
+
+};
+#endif // _StepRepr_RepresentationContextReference_HeaderFile_
--- /dev/null
+// Created on : Sat May 02 12:41:14 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepRepr_RepresentationOrRepresentationReference.hxx>
+#include <StepRepr_Representation.hxx>
+#include <StepRepr_RepresentationReference.hxx>
+
+//=======================================================================
+//function : StepRepr_RepresentationOrRepresentationReference
+//purpose :
+//=======================================================================
+
+StepRepr_RepresentationOrRepresentationReference::StepRepr_RepresentationOrRepresentationReference ()
+{
+}
+
+//=======================================================================
+//function : CaseNum
+//purpose :
+//=======================================================================
+
+Standard_Integer StepRepr_RepresentationOrRepresentationReference::CaseNum (const Handle(Standard_Transient)& ent) const
+{
+ if (ent.IsNull()) return 0;
+ if (ent->IsKind(STANDARD_TYPE(StepRepr_Representation))) return 1;
+ if (ent->IsKind(STANDARD_TYPE(StepRepr_RepresentationReference))) return 2;
+ return 0;
+}
+
+//=======================================================================
+//function : Representation
+//purpose :
+//=======================================================================
+
+Handle(StepRepr_Representation) StepRepr_RepresentationOrRepresentationReference::Representation () const
+{
+ return Handle(StepRepr_Representation)::DownCast(Value());
+}
+
+//=======================================================================
+//function : RepresentationReference
+//purpose :
+//=======================================================================
+
+Handle(StepRepr_RepresentationReference) StepRepr_RepresentationOrRepresentationReference::RepresentationReference () const
+{
+ return Handle(StepRepr_RepresentationReference)::DownCast(Value());
+}
--- /dev/null
+// Created on : Sat May 02 12:41:14 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepRepr_RepresentationOrRepresentationReference_HeaderFile
+#define _StepRepr_RepresentationOrRepresentationReference_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+#include <StepData_SelectType.hxx>
+#include <Standard_Integer.hxx>
+
+class Standard_Transient;
+class StepRepr_Representation;
+class StepRepr_RepresentationReference;
+
+//! Representation of STEP SELECT type RepresentationOrRepresentationReference
+class StepRepr_RepresentationOrRepresentationReference : public StepData_SelectType
+{
+
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ //! Empty constructor
+ Standard_EXPORT StepRepr_RepresentationOrRepresentationReference();
+
+ //! Recognizes a kind of RepresentationOrRepresentationReference select type
+ //! -- 1 -> Representation
+ //! -- 2 -> RepresentationReference
+ Standard_EXPORT Standard_Integer CaseNum (const Handle(Standard_Transient)& ent) const Standard_OVERRIDE;
+
+ //! Returns Value as Representation (or Null if another type)
+ Standard_EXPORT Handle(StepRepr_Representation) Representation() const;
+
+ //! Returns Value as RepresentationReference (or Null if another type)
+ Standard_EXPORT Handle(StepRepr_RepresentationReference) RepresentationReference() const;
+
+};
+#endif // _StepRepr_RepresentationOrRepresentationReference_HeaderFile
--- /dev/null
+// Created on : Sat May 02 12:41:14 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <StepRepr_RepresentationReference.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepRepr_RepresentationReference, Standard_Transient)
+
+//=======================================================================
+//function : StepRepr_RepresentationReference
+//purpose :
+//=======================================================================
+
+StepRepr_RepresentationReference::StepRepr_RepresentationReference ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepRepr_RepresentationReference::Init (const Handle(TCollection_HAsciiString)& theId,
+ const Handle(StepRepr_RepresentationContextReference)& theContextOfItems)
+{
+
+ myId = theId;
+
+ myContextOfItems = theContextOfItems;
+}
+
+//=======================================================================
+//function : Id
+//purpose :
+//=======================================================================
+
+Handle(TCollection_HAsciiString) StepRepr_RepresentationReference::Id () const
+{
+ return myId;
+}
+
+//=======================================================================
+//function : SetId
+//purpose :
+//=======================================================================
+
+void StepRepr_RepresentationReference::SetId (const Handle(TCollection_HAsciiString)& theId)
+{
+ myId = theId;
+}
+
+//=======================================================================
+//function : ContextOfItems
+//purpose :
+//=======================================================================
+
+Handle(StepRepr_RepresentationContextReference) StepRepr_RepresentationReference::ContextOfItems () const
+{
+ return myContextOfItems;
+}
+
+//=======================================================================
+//function : SetContextOfItems
+//purpose :
+//=======================================================================
+
+void StepRepr_RepresentationReference::SetContextOfItems (const Handle(StepRepr_RepresentationContextReference)& theContextOfItems)
+{
+ myContextOfItems = theContextOfItems;
+}
--- /dev/null
+// Created on : Sat May 02 12:41:14 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _StepRepr_RepresentationReference_HeaderFile_
+#define _StepRepr_RepresentationReference_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <Standard_Transient.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationContextReference.hxx>
+
+DEFINE_STANDARD_HANDLE(StepRepr_RepresentationReference, Standard_Transient)
+
+//! Representation of STEP entity RepresentationReference
+class StepRepr_RepresentationReference : public Standard_Transient
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepRepr_RepresentationReference();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theId,
+ const Handle(StepRepr_RepresentationContextReference)& theContextOfItems);
+
+ //! Returns field Id
+ Standard_EXPORT Handle(TCollection_HAsciiString) Id() const;
+ //! Sets field Id
+ Standard_EXPORT void SetId (const Handle(TCollection_HAsciiString)& theId);
+
+ //! Returns field ContextOfItems
+ Standard_EXPORT Handle(StepRepr_RepresentationContextReference) ContextOfItems() const;
+ //! Sets field ContextOfItems
+ Standard_EXPORT void SetContextOfItems (const Handle(StepRepr_RepresentationContextReference)& theContextOfItems);
+
+DEFINE_STANDARD_RTTIEXT(StepRepr_RepresentationReference, Standard_Transient)
+
+private:
+ Handle(TCollection_HAsciiString) myId;
+ Handle(StepRepr_RepresentationContextReference) myContextOfItems;
+
+};
+#endif // _StepRepr_RepresentationReference_HeaderFile_
Standard_EXPORT void SetName (const Handle(TCollection_HAsciiString)& aName);
Standard_EXPORT Handle(TCollection_HAsciiString) Name() const;
+
+ Standard_Boolean HasDescription() { return !description.IsNull(); }
Standard_EXPORT void SetDescription (const Handle(TCollection_HAsciiString)& aDescription);
#include <Interface_Macros.hxx>
#include <Standard_Transient.hxx>
+#include <StepGeom_GeometricRepresentationItem.hxx>
#include <StepRepr_FunctionallyDefinedTransformation.hxx>
#include <StepRepr_ItemDefinedTransformation.hxx>
#include <StepRepr_Transformation.hxx>
if (ent.IsNull()) return 0;
if (ent->IsKind(STANDARD_TYPE(StepRepr_ItemDefinedTransformation))) return 1;
if (ent->IsKind(STANDARD_TYPE(StepRepr_FunctionallyDefinedTransformation))) return 2;
+ if (ent->IsKind(STANDARD_TYPE(StepGeom_GeometricRepresentationItem))) return 1;
return 0;
}
Standard_EXPORT Handle(StepRepr_FunctionallyDefinedTransformation) FunctionallyDefinedTransformation() const;
-
-
protected:
#include <StepGeom_UniformSurface.hxx>
#include <StepGeom_UniformSurfaceAndRationalBSplineSurface.hxx>
#include <StepGeom_Vector.hxx>
+#include <StepGeom_SuParameters.hxx>
+#include <StepKinematics_SpatialRotation.hxx>
+#include <StepKinematics_RotationAboutDirection.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Face.hxx>
#include <StepData_GlobalFactors.hxx>
+#include <StepBasic_ConversionBasedUnitAndPlaneAngleUnit.hxx>
+#include <StepBasic_SiUnitAndPlaneAngleUnit.hxx>
+#include <StepBasic_MeasureWithUnit.hxx>
+#include <StepRepr_GlobalUnitAssignedContext.hxx>
+#include <STEPConstruct_UnitContext.hxx>
//=============================================================================
// Creation d' un Ax1Placement de Geom a partir d' un axis1_placement de Step
return 0;
}
+//=============================================================================
+// Creation of an AxisPlacement from a Kinematic SuParameters for Step
+//=============================================================================
+
+Handle(Geom_Axis2Placement) StepToGeom::MakeAxis2Placement(const Handle(StepGeom_SuParameters)& theSP)
+{
+ Standard_Real aLocX = theSP->A() * cos(theSP->Gamma()) + theSP->B() * sin(theSP->Gamma()) * sin(theSP->Alpha());
+ Standard_Real aLocY = theSP->A() * sin(theSP->Gamma()) - theSP->B() * cos(theSP->Gamma()) * sin(theSP->Alpha());
+ Standard_Real aLocZ = theSP->C() + theSP->B() * cos(theSP->Alpha());
+ Standard_Real anAsisX = sin(theSP->Gamma()) * sin(theSP->Alpha());
+ Standard_Real anAxisY = -cos(theSP->Gamma()) * sin(theSP->Alpha());
+ Standard_Real anAxisZ = cos(theSP->Alpha());
+ Standard_Real aDirX = cos(theSP->Gamma()) * cos(theSP->Beta()) - sin(theSP->Gamma()) * cos(theSP->Alpha()) * sin(theSP->Beta());
+ Standard_Real aDirY = sin(theSP->Gamma()) * cos(theSP->Beta()) + cos(theSP->Gamma()) * cos(theSP->Alpha()) * sin(theSP->Beta());
+ Standard_Real aDirZ = sin(theSP->Alpha())*sin(theSP->Beta());
+ const gp_Pnt Pgp (aLocX, aLocY, aLocZ);
+ const gp_Dir Ngp (anAsisX,anAxisY,anAxisZ);
+ const gp_Dir Vxgp(aDirX, aDirY, aDirZ);
+ gp_Ax2 gpAx2 = gp_Ax2(Pgp, Ngp, Vxgp);
+ return new Geom_Axis2Placement(gpAx2);
+}
+
//=============================================================================
// Creation d' un AxisPlacement de Geom2d a partir d' un axis2_placement_3d de Step
//=============================================================================
}
return 0;
}
+
+//=============================================================================
+// Creation of a YptRotation from a Kinematic SpatialRotation for Step
+//=============================================================================
+
+Handle(TColStd_HArray1OfReal) StepToGeom::MakeYprRotation(const StepKinematics_SpatialRotation& SR, const Handle(StepRepr_GlobalUnitAssignedContext)& theCntxt)
+{
+ //If rotation is already a ypr_rotation, return it immediately
+ Handle(TColStd_HArray1OfReal) anYPRRotation;
+ if (!SR.YprRotation().IsNull() &&
+ SR.YprRotation()->Length() == 3)
+ {
+ return SR.YprRotation();
+ }
+
+ if (SR.RotationAboutDirection().IsNull() ||
+ SR.RotationAboutDirection()->DirectionOfAxis()->DirectionRatios()->Length() != 3 ||
+ theCntxt.IsNull())
+ {
+ return NULL;
+ }
+ //rotation is a rotation_about_direction
+ Handle(Geom_Direction) anAxis;
+ anAxis = new Geom_Direction(SR.RotationAboutDirection()->DirectionOfAxis()->DirectionRatiosValue(1),
+ SR.RotationAboutDirection()->DirectionOfAxis()->DirectionRatiosValue(2),
+ SR.RotationAboutDirection()->DirectionOfAxis()->DirectionRatiosValue(3));
+ Standard_Real anAngle = SR.RotationAboutDirection()->RotationAngle();
+ if (Abs(anAngle) < Precision::Angular())
+ {
+ // a zero rotation is converted trivially
+ anYPRRotation = new TColStd_HArray1OfReal(1, 3);
+ anYPRRotation->SetValue(1, 0.);
+ anYPRRotation->SetValue(2, 0.);
+ anYPRRotation->SetValue(3, 0.);
+ return anYPRRotation;
+ }
+ Standard_Real dx = anAxis->X();
+ Standard_Real dy = anAxis->Y();
+ Standard_Real dz = anAxis->Z();
+ NCollection_Sequence<Handle(StepBasic_NamedUnit)> aPaUnits;
+ for (Standard_Integer anInd = 1; anInd <= theCntxt->Units()->Length(); ++anInd)
+ {
+ if (theCntxt->UnitsValue(anInd)->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndPlaneAngleUnit)) ||
+ theCntxt->UnitsValue(anInd)->IsKind(STANDARD_TYPE(StepBasic_SiUnitAndPlaneAngleUnit)))
+ {
+ aPaUnits.Append(theCntxt->UnitsValue(anInd));
+ }
+ }
+ if (aPaUnits.Length() != 1)
+ {
+ return anYPRRotation;
+ }
+ Handle(StepBasic_NamedUnit) aPau = aPaUnits.Value(1);
+ while (!aPau.IsNull() && aPau->IsKind((STANDARD_TYPE(StepBasic_ConversionBasedUnitAndPlaneAngleUnit))))
+ {
+ Handle(StepBasic_ConversionBasedUnitAndPlaneAngleUnit) aConverUnit = Handle(StepBasic_ConversionBasedUnitAndPlaneAngleUnit)::DownCast(aPau);
+ anAngle = anAngle * aConverUnit->ConversionFactor()->ValueComponent();
+ aPau = aConverUnit->ConversionFactor()->UnitComponent().NamedUnit();
+ }
+ if (aPau.IsNull())
+ {
+ return anYPRRotation;
+ }
+ Handle(StepBasic_SiUnitAndPlaneAngleUnit) aSiUnit = Handle(StepBasic_SiUnitAndPlaneAngleUnit)::DownCast(aPau);
+ if (aSiUnit.IsNull() || aSiUnit->Name() != StepBasic_sunRadian)
+ {
+ return anYPRRotation;
+ }
+ anAngle = (!aSiUnit->HasPrefix() ?
+ 1. : STEPConstruct_UnitContext::ConvertSiPrefix(aSiUnit->Prefix())) * anAngle;
+ Standard_Real anUcf = SR.RotationAboutDirection()->RotationAngle() / anAngle;
+ Standard_Real aSA = Sin(anAngle);
+ Standard_Real aCA = Cos(anAngle);
+ Standard_Real aYaw = 0, aPitch = 0, aRoll = 0;
+
+ // axis parallel either to x-axis or to z-axis?
+ if (Abs(dy) < Precision::Confusion() && Abs(dx * dz) < Precision::SquareConfusion())
+ {
+ while (anAngle <= -M_PI)
+ {
+ anAngle = anAngle + 2 * M_PI;
+ }
+ while (anAngle > M_PI)
+ {
+ anAngle = anAngle - 2 * M_PI;
+ }
+
+ aYaw = anUcf * anAngle;
+ if (Abs(anAngle - M_PI) >= Precision::Angular())
+ {
+ aRoll = -aYaw;
+ }
+ else
+ {
+ aRoll = aYaw;
+ }
+ anYPRRotation = new TColStd_HArray1OfReal(1, 3);
+ anYPRRotation->SetValue(1, 0.);
+ anYPRRotation->SetValue(2, 0.);
+ anYPRRotation->SetValue(3, 0.);
+ if (Abs(dx) >= Precision::Confusion())
+ {
+ if (dx > 0.)
+ anYPRRotation->SetValue(3, aYaw);
+ else
+ anYPRRotation->SetValue(3, aRoll);
+ }
+ else
+ {
+ if (dz > 0.)
+ anYPRRotation->SetValue(1, aYaw);
+ else
+ anYPRRotation->SetValue(1, aRoll);
+ }
+ return anYPRRotation;
+ }
+
+ // axis parallel to y-axis - use y-axis as pitch axis
+ if (Abs(dy) >= Precision::Confusion() && Abs(dx) < Precision::Confusion() && Abs(dz) < Precision::Confusion())
+ {
+ if (aCA >= 0.)
+ {
+ aYaw = 0.0;
+ aRoll = 0.0;
+ }
+ else
+ {
+ aYaw = anUcf * M_PI;
+ aRoll = aYaw;
+ }
+ aPitch = anUcf * ATan2(aSA, Abs(aCA));
+ if (dy < 0.)
+ {
+ aPitch = -aPitch;
+ }
+ anYPRRotation = new TColStd_HArray1OfReal(1, 3);
+ anYPRRotation->SetValue(1, aYaw);
+ anYPRRotation->SetValue(2, aPitch);
+ anYPRRotation->SetValue(3, aRoll);
+ return anYPRRotation;
+ }
+ // axis not parallel to any axis of coordinate system
+ // compute rotation matrix
+ Standard_Real aCm1 = 1 - aCA;
+
+ Standard_Real aRotMat[3][3] = { { dx * dx * aCm1 + aCA ,dx * dy * aCm1 - dz * aSA, dx * dz * aCm1 + dy * aSA },
+ { dx * dy * aCm1 + dz * aSA,dy * dy * aCm1 + aCA, dy * dz * aCm1 - dx * aSA },
+ { dx * dz * aCm1 - dy * aSA, dy * dz * aCm1 + dx * aSA,dz * dz * aCm1 + aCA } };
+
+ // aRotMat[1][3] equals SIN(pitch_angle)
+ if (Abs(Abs(aRotMat[0][2] - 1.)) < Precision::Confusion())
+ {
+ // |aPitch| = PI/2
+ if (Abs(aRotMat[0][2] - 1.) < Precision::Confusion())
+ aPitch = M_PI_2;
+ else
+ aPitch = -M_PI_2;
+ // In this case, only the sum or difference of roll and yaw angles
+ // is relevant and can be evaluated from the matrix.
+ // According to IP `rectangular pitch angle' for ypr_rotation,
+ // the roll angle is set to zero.
+ aRoll = 0.;
+ aYaw = ATan2(aRotMat[1][0], aRotMat[1][1]);
+ // result of ATAN is in the range[-PI / 2, PI / 2].
+ // Here all four quadrants are needed.
+
+ if (aRotMat[1][1] < 0.)
+ {
+ if (aYaw <= 0.)
+ aYaw = aYaw + M_PI;
+ else
+ aYaw = aYaw - M_PI;
+ }
+ }
+ else
+ {
+ // COS (pitch_angle) not equal to zero
+ aYaw = ATan2(-aRotMat[0][1], aRotMat[0][0]);
+
+ if (aRotMat[0][0] < 0.)
+ {
+ if (aYaw < 0. || Abs(aYaw) < Precision::Angular())
+ aYaw = aYaw + M_PI;
+ else
+ aYaw = aYaw - M_PI;
+ }
+ Standard_Real aSY = Sin(aYaw);
+ Standard_Real aCY = Cos(aYaw);
+ Standard_Real aSR = Sin(aRoll);
+ Standard_Real aCR = Cos(aRoll);
+
+ if (Abs(aSY) > Abs(aCY) &&
+ Abs(aSY) > Abs(aSR) &&
+ Abs(aSY) > Abs(aCR))
+ {
+ aCm1 = -aRotMat[0][1] / aSY;
+ }
+ else
+ {
+ if (Abs(aCY) > Abs(aSR) && Abs(aCY) > Abs(aCR))
+ aCm1 = aRotMat[0][0] / aCY;
+ else
+ if (Abs(aSR) > Abs(aCR))
+ aCm1 = -aRotMat[1][2] / aSR;
+ else
+ aCm1 = aRotMat[2][2] / aCR;
+ }
+ aPitch = ATan2(aRotMat[0][2], aCm1);
+ }
+ aYaw = aYaw * anUcf;
+ aPitch = aPitch * anUcf;
+ aRoll = aRoll * anUcf;
+ anYPRRotation = new TColStd_HArray1OfReal(1, 3);
+ anYPRRotation->SetValue(1, aYaw);
+ anYPRRotation->SetValue(2, aPitch);
+ anYPRRotation->SetValue(3, aRoll);
+
+ return anYPRRotation;
+}
class StepGeom_CartesianTransformationOperator3d;
class StepGeom_TrimmedCurve;
class StepGeom_Vector;
+class StepGeom_SuParameters;
+class StepKinematics_SpatialRotation;
+class StepRepr_GlobalUnitAssignedContext;
+class TColStd_HArray1OfReal;
//! This class provides static methods to convert STEP geometric entities to OCCT.
//! The methods returning handles will return null handle in case of error.
Standard_EXPORT static Handle(Geom_Axis1Placement) MakeAxis1Placement (const Handle(StepGeom_Axis1Placement)& SA);
Standard_EXPORT static Handle(Geom_Axis2Placement) MakeAxis2Placement (const Handle(StepGeom_Axis2Placement3d)& SA);
+ Standard_EXPORT static Handle(Geom_Axis2Placement) MakeAxis2Placement (const Handle(StepGeom_SuParameters)& SP);
Standard_EXPORT static Handle(Geom2d_AxisPlacement) MakeAxisPlacement (const Handle(StepGeom_Axis2Placement2d)& SA);
Standard_EXPORT static Handle(Geom_BoundedCurve) MakeBoundedCurve (const Handle(StepGeom_BoundedCurve)& SC);
Standard_EXPORT static Handle(Geom2d_BoundedCurve) MakeBoundedCurve2d (const Handle(StepGeom_BoundedCurve)& SC);
Standard_EXPORT static Handle(Geom2d_BSplineCurve) MakeTrimmedCurve2d (const Handle(StepGeom_TrimmedCurve)& SC);
Standard_EXPORT static Handle(Geom_VectorWithMagnitude) MakeVectorWithMagnitude (const Handle(StepGeom_Vector)& SV);
Standard_EXPORT static Handle(Geom2d_VectorWithMagnitude) MakeVectorWithMagnitude2d (const Handle(StepGeom_Vector)& SV);
+ Standard_EXPORT static Handle(TColStd_HArray1OfReal) MakeYprRotation(const StepKinematics_SpatialRotation& SR, const Handle(StepRepr_GlobalUnitAssignedContext)& theCntxt);
};
#endif // _StepToGeom_HeaderFile
RWStepVisual
StepDimTol
RWStepDimTol
+StepKinematics
+RWStepKinematics
projects / occt.git / commitdiff