#include <RWStepVisual_RWCameraModelD3MultiClippingUnion.hxx>
#include <StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem.hxx>
#include <RWStepVisual_RWAnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem.hxx>
+// Added for kinematics implementation
+#include <StepRepr_RepresentationContextReference.hxx>
+#include <StepRepr_RepresentationReference.hxx>
+#include <StepKinematics_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_KinematicTopologyStructure.hxx>
+#include <StepKinematics_LowOrderKinematicPair.hxx>
+#include <StepKinematics_LowOrderKinematicPairValue.hxx>
+#include <StepKinematics_LowOrderKinematicPairWithRange.hxx>
+#include <StepKinematics_MechanismRepresentation.hxx>
+#include <StepKinematics_OrientedJoint.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_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 <RWStepRepr_RWRepresentationContextReference.hxx>
+#include <RWStepRepr_RWRepresentationReference.hxx>
+#include <RWStepKinematics_RWSuParameters.hxx>
+#include <RWStepKinematics_RWRotationAboutDirection.hxx>
+#include <RWStepKinematics_RWKinematicJoint.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_RWKinematicLink.hxx>
+#include <RWStepKinematics_RWKinematicLinkRepresentationAssociation.hxx>
+#include <RWStepKinematics_RWKinematicPropertyMechanismRepresentation.hxx>
+#include <RWStepKinematics_RWKinematicTopologyStructure.hxx>
+#include <RWStepKinematics_RWLowOrderKinematicPair.hxx>
+#include <RWStepKinematics_RWLowOrderKinematicPairValue.hxx>
+#include <RWStepKinematics_RWLowOrderKinematicPairWithRange.hxx>
+#include <RWStepKinematics_RWMechanismRepresentation.hxx>
+#include <RWStepKinematics_RWOrientedJoint.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_RWRollingCurvePair.hxx>
+#include <RWStepKinematics_RWRollingCurvePairValue.hxx>
+#include <RWStepKinematics_RWRollingSurfacePair.hxx>
+#include <RWStepKinematics_RWRollingSurfacePairValue.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>
static Standard_Integer catsh,catdr,catstr,catdsc,cataux;
DeclareAndCast(StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem, anent, ent);
RWStepVisual_RWAnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem tool;
tool.Share(anent, iter);
+ }
+ case 720:
+ {
+ DeclareAndCast(StepRepr_RepresentationContextReference, anent, ent);
+ RWStepRepr_RWRepresentationContextReference tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 721:
+ {
+ DeclareAndCast(StepRepr_RepresentationReference, anent, ent);
+ RWStepRepr_RWRepresentationReference tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 722:
+ {
+ DeclareAndCast(StepKinematics_SuParameters, anent, ent);
+ RWStepKinematics_RWSuParameters tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 723:
+ {
+ DeclareAndCast(StepKinematics_RotationAboutDirection, anent, ent);
+ RWStepKinematics_RWRotationAboutDirection tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 724:
+ {
+ DeclareAndCast(StepKinematics_KinematicJoint, anent, ent);
+ RWStepKinematics_RWKinematicJoint tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 725:
+ {
+ DeclareAndCast(StepKinematics_ActuatedKinematicPair, anent, ent);
+ RWStepKinematics_RWActuatedKinematicPair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 726:
+ {
+ DeclareAndCast(StepKinematics_ContextDependentKinematicLinkRepresentation, anent, ent);
+ RWStepKinematics_RWContextDependentKinematicLinkRepresentation tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 727:
+ {
+ DeclareAndCast(StepKinematics_CylindricalPair, anent, ent);
+ RWStepKinematics_RWCylindricalPair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 728:
+ {
+ DeclareAndCast(StepKinematics_CylindricalPairValue, anent, ent);
+ RWStepKinematics_RWCylindricalPairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 729:
+ {
+ DeclareAndCast(StepKinematics_CylindricalPairWithRange, anent, ent);
+ RWStepKinematics_RWCylindricalPairWithRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 730:
+ {
+ DeclareAndCast(StepKinematics_FullyConstrainedPair, anent, ent);
+ RWStepKinematics_RWFullyConstrainedPair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 731:
+ {
+ DeclareAndCast(StepKinematics_GearPair, anent, ent);
+ RWStepKinematics_RWGearPair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 732:
+ {
+ DeclareAndCast(StepKinematics_GearPairValue, anent, ent);
+ RWStepKinematics_RWGearPairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 733:
+ {
+ DeclareAndCast(StepKinematics_GearPairWithRange, anent, ent);
+ RWStepKinematics_RWGearPairWithRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 734:
+ {
+ DeclareAndCast(StepKinematics_HomokineticPair, anent, ent);
+ RWStepKinematics_RWHomokineticPair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 735:
+ {
+ DeclareAndCast(StepKinematics_KinematicLink, anent, ent);
+ RWStepKinematics_RWKinematicLink tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 736:
+ {
+ DeclareAndCast(StepKinematics_KinematicLinkRepresentationAssociation, anent, ent);
+ RWStepKinematics_RWKinematicLinkRepresentationAssociation tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 737:
+ {
+ DeclareAndCast(StepKinematics_KinematicPropertyMechanismRepresentation, anent, ent);
+ RWStepKinematics_RWKinematicPropertyMechanismRepresentation tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 738:
+ {
+ DeclareAndCast(StepKinematics_KinematicTopologyStructure, anent, ent);
+ RWStepKinematics_RWKinematicTopologyStructure tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 739:
+ {
+ DeclareAndCast(StepKinematics_LowOrderKinematicPair, anent, ent);
+ RWStepKinematics_RWLowOrderKinematicPair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 740:
+ {
+ DeclareAndCast(StepKinematics_LowOrderKinematicPairValue, anent, ent);
+ RWStepKinematics_RWLowOrderKinematicPairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 741:
+ {
+ DeclareAndCast(StepKinematics_LowOrderKinematicPairWithRange, anent, ent);
+ RWStepKinematics_RWLowOrderKinematicPairWithRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 742:
+ {
+ DeclareAndCast(StepKinematics_MechanismRepresentation, anent, ent);
+ RWStepKinematics_RWMechanismRepresentation tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 743:
+ {
+ DeclareAndCast(StepKinematics_OrientedJoint, anent, ent);
+ RWStepKinematics_RWOrientedJoint tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 744:
+ {
+ DeclareAndCast(StepKinematics_PlanarCurvePair, anent, ent);
+ RWStepKinematics_RWPlanarCurvePair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 745:
+ {
+ DeclareAndCast(StepKinematics_PlanarCurvePairRange, anent, ent);
+ RWStepKinematics_RWPlanarCurvePairRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 746:
+ {
+ DeclareAndCast(StepKinematics_PlanarPair, anent, ent);
+ RWStepKinematics_RWPlanarPair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 747:
+ {
+ DeclareAndCast(StepKinematics_PlanarPairValue, anent, ent);
+ RWStepKinematics_RWPlanarPairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 748:
+ {
+ DeclareAndCast(StepKinematics_PlanarPairWithRange, anent, ent);
+ RWStepKinematics_RWPlanarPairWithRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 749:
+ {
+ DeclareAndCast(StepKinematics_PointOnPlanarCurvePair, anent, ent);
+ RWStepKinematics_RWPointOnPlanarCurvePair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 750:
+ {
+ DeclareAndCast(StepKinematics_PointOnPlanarCurvePairValue, anent, ent);
+ RWStepKinematics_RWPointOnPlanarCurvePairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 751:
+ {
+ DeclareAndCast(StepKinematics_PointOnPlanarCurvePairWithRange, anent, ent);
+ RWStepKinematics_RWPointOnPlanarCurvePairWithRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 752:
+ {
+ DeclareAndCast(StepKinematics_PointOnSurfacePair, anent, ent);
+ RWStepKinematics_RWPointOnSurfacePair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 753:
+ {
+ DeclareAndCast(StepKinematics_PointOnSurfacePairValue, anent, ent);
+ RWStepKinematics_RWPointOnSurfacePairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 754:
+ {
+ DeclareAndCast(StepKinematics_PointOnSurfacePairWithRange, anent, ent);
+ RWStepKinematics_RWPointOnSurfacePairWithRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 755:
+ {
+ DeclareAndCast(StepKinematics_PrismaticPair, anent, ent);
+ RWStepKinematics_RWPrismaticPair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 756:
+ {
+ DeclareAndCast(StepKinematics_PrismaticPairValue, anent, ent);
+ RWStepKinematics_RWPrismaticPairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 757:
+ {
+ DeclareAndCast(StepKinematics_PrismaticPairWithRange, anent, ent);
+ RWStepKinematics_RWPrismaticPairWithRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 758:
+ {
+ DeclareAndCast(StepKinematics_ProductDefinitionKinematics, anent, ent);
+ RWStepKinematics_RWProductDefinitionKinematics tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 759:
+ {
+ DeclareAndCast(StepKinematics_ProductDefinitionRelationshipKinematics, anent, ent);
+ RWStepKinematics_RWProductDefinitionRelationshipKinematics tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 760:
+ {
+ DeclareAndCast(StepKinematics_RackAndPinionPair, anent, ent);
+ RWStepKinematics_RWRackAndPinionPair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 761:
+ {
+ DeclareAndCast(StepKinematics_RackAndPinionPairValue, anent, ent);
+ RWStepKinematics_RWRackAndPinionPairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 762:
+ {
+ DeclareAndCast(StepKinematics_RackAndPinionPairWithRange, anent, ent);
+ RWStepKinematics_RWRackAndPinionPairWithRange tool;
+ tool.Share(anent, iter);
}
+ break;
+ case 763:
+ {
+ DeclareAndCast(StepKinematics_RevolutePair, anent, ent);
+ RWStepKinematics_RWRevolutePair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 764:
+ {
+ DeclareAndCast(StepKinematics_RevolutePairValue, anent, ent);
+ RWStepKinematics_RWRevolutePairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 765:
+ {
+ DeclareAndCast(StepKinematics_RevolutePairWithRange, anent, ent);
+ RWStepKinematics_RWRevolutePairWithRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 766:
+ {
+ DeclareAndCast(StepKinematics_RollingCurvePair, anent, ent);
+ RWStepKinematics_RWRollingCurvePair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 767:
+ {
+ DeclareAndCast(StepKinematics_RollingCurvePairValue, anent, ent);
+ RWStepKinematics_RWRollingCurvePairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 768:
+ {
+ DeclareAndCast(StepKinematics_RollingSurfacePair, anent, ent);
+ RWStepKinematics_RWRollingSurfacePair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 769:
+ {
+ DeclareAndCast(StepKinematics_RollingSurfacePairValue, anent, ent);
+ RWStepKinematics_RWRollingSurfacePairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 770:
+ {
+ DeclareAndCast(StepKinematics_ScrewPair, anent, ent);
+ RWStepKinematics_RWScrewPair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 771:
+ {
+ DeclareAndCast(StepKinematics_ScrewPairValue, anent, ent);
+ RWStepKinematics_RWScrewPairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 772:
+ {
+ DeclareAndCast(StepKinematics_ScrewPairWithRange, anent, ent);
+ RWStepKinematics_RWScrewPairWithRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 773:
+ {
+ DeclareAndCast(StepKinematics_SlidingCurvePair, anent, ent);
+ RWStepKinematics_RWSlidingCurvePair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 774:
+ {
+ DeclareAndCast(StepKinematics_SlidingCurvePairValue, anent, ent);
+ RWStepKinematics_RWSlidingCurvePairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 775:
+ {
+ DeclareAndCast(StepKinematics_SlidingSurfacePair, anent, ent);
+ RWStepKinematics_RWSlidingSurfacePair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 776:
+ {
+ DeclareAndCast(StepKinematics_SlidingSurfacePairValue, anent, ent);
+ RWStepKinematics_RWSlidingSurfacePairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 777:
+ {
+ DeclareAndCast(StepKinematics_SphericalPair, anent, ent);
+ RWStepKinematics_RWSphericalPair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 778:
+ {
+ DeclareAndCast(StepKinematics_SphericalPairValue, anent, ent);
+ RWStepKinematics_RWSphericalPairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 779:
+ {
+ DeclareAndCast(StepKinematics_SphericalPairWithPin, anent, ent);
+ RWStepKinematics_RWSphericalPairWithPin tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 780:
+ {
+ DeclareAndCast(StepKinematics_SphericalPairWithPinAndRange, anent, ent);
+ RWStepKinematics_RWSphericalPairWithPinAndRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 781:
+ {
+ DeclareAndCast(StepKinematics_SphericalPairWithRange, anent, ent);
+ RWStepKinematics_RWSphericalPairWithRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 782:
+ {
+ DeclareAndCast(StepKinematics_SurfacePairWithRange, anent, ent);
+ RWStepKinematics_RWSurfacePairWithRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 783:
+ {
+ DeclareAndCast(StepKinematics_UnconstrainedPair, anent, ent);
+ RWStepKinematics_RWUnconstrainedPair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 784:
+ {
+ DeclareAndCast(StepKinematics_UnconstrainedPairValue, anent, ent);
+ RWStepKinematics_RWUnconstrainedPairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 785:
+ {
+ DeclareAndCast(StepKinematics_UniversalPair, anent, ent);
+ RWStepKinematics_RWUniversalPair tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 786:
+ {
+ DeclareAndCast(StepKinematics_UniversalPairValue, anent, ent);
+ RWStepKinematics_RWUniversalPairValue tool;
+ tool.Share(anent, iter);
+ }
+ break;
+ case 787:
+ {
+ DeclareAndCast(StepKinematics_UniversalPairWithRange, anent, ent);
+ RWStepKinematics_RWUniversalPairWithRange tool;
+ tool.Share(anent, iter);
+ }
+ break;
+
break;
default : break;
}
case 719:
ent = new StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem;
break;
+ case 720:
+ ent = new StepRepr_RepresentationContextReference;
+ break;
+ case 721:
+ ent = new StepRepr_RepresentationReference;
+ break;
+ case 722:
+ ent = new StepKinematics_SuParameters;
+ break;
+ case 723:
+ ent = new StepKinematics_RotationAboutDirection;
+ break;
+ case 724:
+ ent = new StepKinematics_KinematicJoint;
+ break;
+ case 725:
+ ent = new StepKinematics_ActuatedKinematicPair;
+ break;
+ case 726:
+ ent = new StepKinematics_ContextDependentKinematicLinkRepresentation;
+ break;
+ case 727:
+ ent = new StepKinematics_CylindricalPair;
+ break;
+ case 728:
+ ent = new StepKinematics_CylindricalPairValue;
+ break;
+ case 729:
+ ent = new StepKinematics_CylindricalPairWithRange;
+ break;
+ case 730:
+ ent = new StepKinematics_FullyConstrainedPair;
+ break;
+ case 731:
+ ent = new StepKinematics_GearPair;
+ break;
+ case 732:
+ ent = new StepKinematics_GearPairValue;
+ break;
+ case 733:
+ ent = new StepKinematics_GearPairWithRange;
+ break;
+ case 734:
+ ent = new StepKinematics_HomokineticPair;
+ break;
+ case 735:
+ ent = new StepKinematics_KinematicLink;
+ break;
+ case 736:
+ ent = new StepKinematics_KinematicLinkRepresentationAssociation;
+ break;
+ case 737:
+ ent = new StepKinematics_KinematicPropertyMechanismRepresentation;
+ break;
+ case 738:
+ ent = new StepKinematics_KinematicTopologyStructure;
+ break;
+ case 739:
+ ent = new StepKinematics_LowOrderKinematicPair;
+ break;
+ case 740:
+ ent = new StepKinematics_LowOrderKinematicPairValue;
+ break;
+ case 741:
+ ent = new StepKinematics_LowOrderKinematicPairWithRange;
+ break;
+ case 742:
+ ent = new StepKinematics_MechanismRepresentation;
+ break;
+ case 743:
+ ent = new StepKinematics_OrientedJoint;
+ break;
+ case 744:
+ ent = new StepKinematics_PlanarCurvePair;
+ break;
+ case 745:
+ ent = new StepKinematics_PlanarCurvePairRange;
+ break;
+ case 746:
+ ent = new StepKinematics_PlanarPair;
+ break;
+ case 747:
+ ent = new StepKinematics_PlanarPairValue;
+ break;
+ case 748:
+ ent = new StepKinematics_PlanarPairWithRange;
+ break;
+ case 749:
+ ent = new StepKinematics_PointOnPlanarCurvePair;
+ break;
+ case 750:
+ ent = new StepKinematics_PointOnPlanarCurvePairValue;
+ break;
+ case 751:
+ ent = new StepKinematics_PointOnPlanarCurvePairWithRange;
+ break;
+ case 752:
+ ent = new StepKinematics_PointOnSurfacePair;
+ break;
+ case 753:
+ ent = new StepKinematics_PointOnSurfacePairValue;
+ break;
+ case 754:
+ ent = new StepKinematics_PointOnSurfacePairWithRange;
+ break;
+ case 755:
+ ent = new StepKinematics_PrismaticPair;
+ break;
+ case 756:
+ ent = new StepKinematics_PrismaticPairValue;
+ break;
+ case 757:
+ ent = new StepKinematics_PrismaticPairWithRange;
+ break;
+ case 758:
+ ent = new StepKinematics_ProductDefinitionKinematics;
+ break;
+ case 759:
+ ent = new StepKinematics_ProductDefinitionRelationshipKinematics;
+ break;
+ case 760:
+ ent = new StepKinematics_RackAndPinionPair;
+ break;
+ case 761:
+ ent = new StepKinematics_RackAndPinionPairValue;
+ break;
+ case 762:
+ ent = new StepKinematics_RackAndPinionPairWithRange;
+ break;
+ case 763:
+ ent = new StepKinematics_RevolutePair;
+ break;
+ case 764:
+ ent = new StepKinematics_RevolutePairValue;
+ break;
+ case 765:
+ ent = new StepKinematics_RevolutePairWithRange;
+ break;
+ case 766:
+ ent = new StepKinematics_RollingCurvePair;
+ break;
+ case 767:
+ ent = new StepKinematics_RollingCurvePairValue;
+ break;
+ case 768:
+ ent = new StepKinematics_RollingSurfacePair;
+ break;
+ case 769:
+ ent = new StepKinematics_RollingSurfacePairValue;
+ break;
+ case 770:
+ ent = new StepKinematics_ScrewPair;
+ break;
+ case 771:
+ ent = new StepKinematics_ScrewPairValue;
+ break;
+ case 772:
+ ent = new StepKinematics_ScrewPairWithRange;
+ break;
+ case 773:
+ ent = new StepKinematics_SlidingCurvePair;
+ break;
+ case 774:
+ ent = new StepKinematics_SlidingCurvePairValue;
+ break;
+ case 775:
+ ent = new StepKinematics_SlidingSurfacePair;
+ break;
+ case 776:
+ ent = new StepKinematics_SlidingSurfacePairValue;
+ break;
+ case 777:
+ ent = new StepKinematics_SphericalPair;
+ break;
+ case 778:
+ ent = new StepKinematics_SphericalPairValue;
+ break;
+ case 779:
+ ent = new StepKinematics_SphericalPairWithPin;
+ break;
+ case 780:
+ ent = new StepKinematics_SphericalPairWithPinAndRange;
+ break;
+ case 781:
+ ent = new StepKinematics_SphericalPairWithRange;
+ break;
+ case 782:
+ ent = new StepKinematics_SurfacePairWithRange;
+ break;
+ case 783:
+ ent = new StepKinematics_UnconstrainedPair;
+ break;
+ case 784:
+ ent = new StepKinematics_UnconstrainedPairValue;
+ break;
+ case 785:
+ ent = new StepKinematics_UniversalPair;
+ break;
+ case 786:
+ ent = new StepKinematics_UniversalPairValue;
+ break;
+ case 787:
+ ent = new StepKinematics_UniversalPairWithRange;
+ break;
default:
case 717:
case 718: return cataux;
case 719: return catdr;
+ case 720: return cataux;
+ case 721: return cataux;
+ case 722: return cataux;
+ case 723: return cataux;
+ 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;
+
default : break;
}
#include <RWStepVisual_RWCameraModelD3MultiClippingUnion.hxx>
#include <StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem.hxx>
#include <RWStepVisual_RWAnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem.hxx>
+// Added for kinematics implementation
+#include <StepRepr_RepresentationContextReference.hxx>
+#include <StepRepr_RepresentationReference.hxx>
+#include <StepKinematics_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_KinematicTopologyStructure.hxx>
+#include <StepKinematics_LowOrderKinematicPair.hxx>
+#include <StepKinematics_LowOrderKinematicPairValue.hxx>
+#include <StepKinematics_LowOrderKinematicPairWithRange.hxx>
+#include <StepKinematics_MechanismRepresentation.hxx>
+#include <StepKinematics_OrientedJoint.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_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 <RWStepRepr_RWRepresentationContextReference.hxx>
+#include <RWStepRepr_RWRepresentationReference.hxx>
+#include <RWStepKinematics_RWSuParameters.hxx>
+#include <RWStepKinematics_RWRotationAboutDirection.hxx>
+#include <RWStepKinematics_RWKinematicJoint.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_RWKinematicLink.hxx>
+#include <RWStepKinematics_RWKinematicLinkRepresentationAssociation.hxx>
+#include <RWStepKinematics_RWKinematicPropertyMechanismRepresentation.hxx>
+#include <RWStepKinematics_RWKinematicTopologyStructure.hxx>
+#include <RWStepKinematics_RWLowOrderKinematicPair.hxx>
+#include <RWStepKinematics_RWLowOrderKinematicPairValue.hxx>
+#include <RWStepKinematics_RWLowOrderKinematicPairWithRange.hxx>
+#include <RWStepKinematics_RWMechanismRepresentation.hxx>
+#include <RWStepKinematics_RWOrientedJoint.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_RWRollingCurvePair.hxx>
+#include <RWStepKinematics_RWRollingCurvePairValue.hxx>
+#include <RWStepKinematics_RWRollingSurfacePair.hxx>
+#include <RWStepKinematics_RWRollingSurfacePairValue.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>
// -- General Declarations (Recognize, StepType) ---
static TCollection_AsciiString Reco_CameraModelD3MultiClipping("CAMERA_MODEL_D3_MULTI_CLIPPING");
static TCollection_AsciiString Reco_CameraModelD3MultiClippingIntersection("CAMERA_MODEL_D3_MULTI_CLIPPING_INTERSECTION");
static TCollection_AsciiString Reco_CameraModelD3MultiClippingUnion("CAMERA_MODEL_D3_MULTI_CLIPPING_UNION");
+
+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_KinematicTopologyStructure("KINEMATIC_TOPOLOGY_STRUCTURE");
+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_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_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");
+
// -- Definition of the libraries --
static NCollection_DataMap<TCollection_AsciiString, Standard_Integer> typenums;
typenums.Bind ( Reco_CameraModelD3MultiClippingIntersection, 717);
typenums.Bind ( Reco_CameraModelD3MultiClippingUnion, 718);
+ typenums.Bind(Reco_RepresentationContextReference, 720);
+ typenums.Bind(Reco_RepresentationReference, 721);
+ typenums.Bind(Reco_SuParameters, 722);
+ typenums.Bind(Reco_RotationAboutDirection, 723);
+ typenums.Bind(Reco_KinematicJoint, 724);
+ typenums.Bind(Reco_ActuatedKinematicPair, 725);
+ typenums.Bind(Reco_ContextDependentKinematicLinkRepresentation, 726);
+ typenums.Bind(Reco_CylindricalPair, 727);
+ typenums.Bind(Reco_CylindricalPairValue, 728);
+ typenums.Bind(Reco_CylindricalPairWithRange, 729);
+ typenums.Bind(Reco_FullyConstrainedPair, 730);
+ typenums.Bind(Reco_GearPair, 731);
+ typenums.Bind(Reco_GearPairValue, 732);
+ typenums.Bind(Reco_GearPairWithRange, 733);
+ typenums.Bind(Reco_HomokineticPair, 734);
+ typenums.Bind(Reco_KinematicLink, 735);
+ typenums.Bind(Reco_KinematicLinkRepresentationAssociation, 736);
+ typenums.Bind(Reco_KinematicPropertyMechanismRepresentation, 737);
+ typenums.Bind(Reco_KinematicTopologyStructure, 738);
+ typenums.Bind(Reco_LowOrderKinematicPair, 739);
+ typenums.Bind(Reco_LowOrderKinematicPairValue, 740);
+ typenums.Bind(Reco_LowOrderKinematicPairWithRange, 741);
+ typenums.Bind(Reco_MechanismRepresentation, 742);
+ typenums.Bind(Reco_OrientedJoint, 743);
+ typenums.Bind(Reco_PlanarCurvePair, 744);
+ typenums.Bind(Reco_PlanarCurvePairRange, 745);
+ typenums.Bind(Reco_PlanarPair, 746);
+ typenums.Bind(Reco_PlanarPairValue, 747);
+ typenums.Bind(Reco_PlanarPairWithRange, 748);
+ typenums.Bind(Reco_PointOnPlanarCurvePair, 749);
+ typenums.Bind(Reco_PointOnPlanarCurvePairValue, 750);
+ typenums.Bind(Reco_PointOnPlanarCurvePairWithRange, 751);
+ typenums.Bind(Reco_PointOnSurfacePair, 752);
+ typenums.Bind(Reco_PointOnSurfacePairValue, 753);
+ typenums.Bind(Reco_PointOnSurfacePairWithRange, 754);
+ typenums.Bind(Reco_PrismaticPair, 755);
+ typenums.Bind(Reco_PrismaticPairValue, 756);
+ typenums.Bind(Reco_PrismaticPairWithRange, 757);
+ typenums.Bind(Reco_ProductDefinitionKinematics, 758);
+ typenums.Bind(Reco_ProductDefinitionRelationshipKinematics, 759);
+ typenums.Bind(Reco_RackAndPinionPair, 760);
+ typenums.Bind(Reco_RackAndPinionPairValue, 761);
+ typenums.Bind(Reco_RackAndPinionPairWithRange, 762);
+ typenums.Bind(Reco_RevolutePair, 763);
+ typenums.Bind(Reco_RevolutePairValue, 764);
+ typenums.Bind(Reco_RevolutePairWithRange, 765);
+ typenums.Bind(Reco_RollingCurvePair, 766);
+ typenums.Bind(Reco_RollingCurvePairValue, 767);
+ typenums.Bind(Reco_RollingSurfacePair, 768);
+ typenums.Bind(Reco_RollingSurfacePairValue, 769);
+ typenums.Bind(Reco_ScrewPair, 770);
+ typenums.Bind(Reco_ScrewPairValue, 771);
+ typenums.Bind(Reco_ScrewPairWithRange, 772);
+ typenums.Bind(Reco_SlidingCurvePair, 773);
+ typenums.Bind(Reco_SlidingCurvePairValue, 774);
+ typenums.Bind(Reco_SlidingSurfacePair, 775);
+ typenums.Bind(Reco_SlidingSurfacePairValue, 776);
+ typenums.Bind(Reco_SphericalPair, 777);
+ typenums.Bind(Reco_SphericalPairValue, 778);
+ typenums.Bind(Reco_SphericalPairWithPin, 779);
+ typenums.Bind(Reco_SphericalPairWithPinAndRange, 780);
+ typenums.Bind(Reco_SphericalPairWithRange, 781);
+ typenums.Bind(Reco_SurfacePairWithRange, 782);
+ typenums.Bind(Reco_UnconstrainedPair, 783);
+ typenums.Bind(Reco_UnconstrainedPairValue, 784);
+ typenums.Bind(Reco_UniversalPair, 785);
+ typenums.Bind(Reco_UniversalPairValue, 786);
+ typenums.Bind(Reco_UniversalPairWithRange, 787);
+
+
// SHORT NAMES
// NB : la liste est celle de AP203
case 717 : return Reco_CameraModelD3MultiClippingIntersection;
case 718 : return Reco_CameraModelD3MultiClippingUnion;
+ case 720: return Reco_RepresentationContextReference;
+ case 721: return Reco_RepresentationReference;
+ case 722: return Reco_SuParameters;
+ case 723: return Reco_RotationAboutDirection;
+ case 724: return Reco_KinematicJoint;
+ case 725: return Reco_ActuatedKinematicPair;
+ case 726: return Reco_ContextDependentKinematicLinkRepresentation;
+ case 727: return Reco_CylindricalPair;
+ case 728: return Reco_CylindricalPairValue;
+ case 729: return Reco_CylindricalPairWithRange;
+ case 730: return Reco_FullyConstrainedPair;
+ case 731: return Reco_GearPair;
+ case 732: return Reco_GearPairValue;
+ case 733: return Reco_GearPairWithRange;
+ case 734: return Reco_HomokineticPair;
+ case 735: return Reco_KinematicLink;
+ case 736: return Reco_KinematicLinkRepresentationAssociation;
+ case 737: return Reco_KinematicPropertyMechanismRepresentation;
+ case 738: return Reco_KinematicTopologyStructure;
+ case 739: return Reco_LowOrderKinematicPair;
+ case 740: return Reco_LowOrderKinematicPairValue;
+ case 741: return Reco_LowOrderKinematicPairWithRange;
+ case 742: return Reco_MechanismRepresentation;
+ case 743: return Reco_OrientedJoint;
+ case 744: return Reco_PlanarCurvePair;
+ case 745: return Reco_PlanarCurvePairRange;
+ case 746: return Reco_PlanarPair;
+ case 747: return Reco_PlanarPairValue;
+ case 748: return Reco_PlanarPairWithRange;
+ case 749: return Reco_PointOnPlanarCurvePair;
+ case 750: return Reco_PointOnPlanarCurvePairValue;
+ case 751: return Reco_PointOnPlanarCurvePairWithRange;
+ case 752: return Reco_PointOnSurfacePair;
+ case 753: return Reco_PointOnSurfacePairValue;
+ case 754: return Reco_PointOnSurfacePairWithRange;
+ case 755: return Reco_PrismaticPair;
+ case 756: return Reco_PrismaticPairValue;
+ case 757: return Reco_PrismaticPairWithRange;
+ case 758: return Reco_ProductDefinitionKinematics;
+ case 759: return Reco_ProductDefinitionRelationshipKinematics;
+ case 760: return Reco_RackAndPinionPair;
+ case 761: return Reco_RackAndPinionPairValue;
+ case 762: return Reco_RackAndPinionPairWithRange;
+ case 763: return Reco_RevolutePair;
+ case 764: return Reco_RevolutePairValue;
+ case 765: return Reco_RevolutePairWithRange;
+ case 766: return Reco_RollingCurvePair;
+ case 767: return Reco_RollingCurvePairValue;
+ case 768: return Reco_RollingSurfacePair;
+ case 769: return Reco_RollingSurfacePairValue;
+ case 770: return Reco_ScrewPair;
+ case 771: return Reco_ScrewPairValue;
+ case 772: return Reco_ScrewPairWithRange;
+ case 773: return Reco_SlidingCurvePair;
+ case 774: return Reco_SlidingCurvePairValue;
+ case 775: return Reco_SlidingSurfacePair;
+ case 776: return Reco_SlidingSurfacePairValue;
+ case 777: return Reco_SphericalPair;
+ case 778: return Reco_SphericalPairValue;
+ case 779: return Reco_SphericalPairWithPin;
+ case 780: return Reco_SphericalPairWithPinAndRange;
+ case 781: return Reco_SphericalPairWithRange;
+ case 782: return Reco_SurfacePairWithRange;
+ case 783: return Reco_UnconstrainedPair;
+ case 784: return Reco_UnconstrainedPairValue;
+ case 785: return Reco_UniversalPair;
+ case 786: return Reco_UniversalPairValue;
+ case 787: return Reco_UniversalPairWithRange;
+
+
default : return PasReco;
}
}
tool.ReadStep(data, num, ach, anent);
}
break;
+ case 720:
+ {
+ DeclareAndCast(StepRepr_RepresentationContextReference, anent, ent);
+ RWStepRepr_RWRepresentationContextReference tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 721:
+ {
+ DeclareAndCast(StepRepr_RepresentationReference, anent, ent);
+ RWStepRepr_RWRepresentationReference tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 722:
+ {
+ DeclareAndCast(StepKinematics_SuParameters, anent, ent);
+ RWStepKinematics_RWSuParameters tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 723:
+ {
+ DeclareAndCast(StepKinematics_RotationAboutDirection, anent, ent);
+ RWStepKinematics_RWRotationAboutDirection tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 724:
+ {
+ DeclareAndCast(StepKinematics_KinematicJoint, anent, ent);
+ RWStepKinematics_RWKinematicJoint tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 725:
+ {
+ DeclareAndCast(StepKinematics_ActuatedKinematicPair, anent, ent);
+ RWStepKinematics_RWActuatedKinematicPair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 726:
+ {
+ DeclareAndCast(StepKinematics_ContextDependentKinematicLinkRepresentation, anent, ent);
+ RWStepKinematics_RWContextDependentKinematicLinkRepresentation tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 727:
+ {
+ DeclareAndCast(StepKinematics_CylindricalPair, anent, ent);
+ RWStepKinematics_RWCylindricalPair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 728:
+ {
+ DeclareAndCast(StepKinematics_CylindricalPairValue, anent, ent);
+ RWStepKinematics_RWCylindricalPairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 729:
+ {
+ DeclareAndCast(StepKinematics_CylindricalPairWithRange, anent, ent);
+ RWStepKinematics_RWCylindricalPairWithRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 730:
+ {
+ DeclareAndCast(StepKinematics_FullyConstrainedPair, anent, ent);
+ RWStepKinematics_RWFullyConstrainedPair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 731:
+ {
+ DeclareAndCast(StepKinematics_GearPair, anent, ent);
+ RWStepKinematics_RWGearPair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 732:
+ {
+ DeclareAndCast(StepKinematics_GearPairValue, anent, ent);
+ RWStepKinematics_RWGearPairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 733:
+ {
+ DeclareAndCast(StepKinematics_GearPairWithRange, anent, ent);
+ RWStepKinematics_RWGearPairWithRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 734:
+ {
+ DeclareAndCast(StepKinematics_HomokineticPair, anent, ent);
+ RWStepKinematics_RWHomokineticPair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 735:
+ {
+ DeclareAndCast(StepKinematics_KinematicLink, anent, ent);
+ RWStepKinematics_RWKinematicLink tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 736:
+ {
+ DeclareAndCast(StepKinematics_KinematicLinkRepresentationAssociation, anent, ent);
+ RWStepKinematics_RWKinematicLinkRepresentationAssociation tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 737:
+ {
+ DeclareAndCast(StepKinematics_KinematicPropertyMechanismRepresentation, anent, ent);
+ RWStepKinematics_RWKinematicPropertyMechanismRepresentation tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 738:
+ {
+ DeclareAndCast(StepKinematics_KinematicTopologyStructure, anent, ent);
+ RWStepKinematics_RWKinematicTopologyStructure tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 739:
+ {
+ DeclareAndCast(StepKinematics_LowOrderKinematicPair, anent, ent);
+ RWStepKinematics_RWLowOrderKinematicPair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 740:
+ {
+ DeclareAndCast(StepKinematics_LowOrderKinematicPairValue, anent, ent);
+ RWStepKinematics_RWLowOrderKinematicPairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 741:
+ {
+ DeclareAndCast(StepKinematics_LowOrderKinematicPairWithRange, anent, ent);
+ RWStepKinematics_RWLowOrderKinematicPairWithRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 742:
+ {
+ DeclareAndCast(StepKinematics_MechanismRepresentation, anent, ent);
+ RWStepKinematics_RWMechanismRepresentation tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 743:
+ {
+ DeclareAndCast(StepKinematics_OrientedJoint, anent, ent);
+ RWStepKinematics_RWOrientedJoint tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 744:
+ {
+ DeclareAndCast(StepKinematics_PlanarCurvePair, anent, ent);
+ RWStepKinematics_RWPlanarCurvePair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 745:
+ {
+ DeclareAndCast(StepKinematics_PlanarCurvePairRange, anent, ent);
+ RWStepKinematics_RWPlanarCurvePairRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 746:
+ {
+ DeclareAndCast(StepKinematics_PlanarPair, anent, ent);
+ RWStepKinematics_RWPlanarPair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 747:
+ {
+ DeclareAndCast(StepKinematics_PlanarPairValue, anent, ent);
+ RWStepKinematics_RWPlanarPairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 748:
+ {
+ DeclareAndCast(StepKinematics_PlanarPairWithRange, anent, ent);
+ RWStepKinematics_RWPlanarPairWithRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 749:
+ {
+ DeclareAndCast(StepKinematics_PointOnPlanarCurvePair, anent, ent);
+ RWStepKinematics_RWPointOnPlanarCurvePair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 750:
+ {
+ DeclareAndCast(StepKinematics_PointOnPlanarCurvePairValue, anent, ent);
+ RWStepKinematics_RWPointOnPlanarCurvePairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 751:
+ {
+ DeclareAndCast(StepKinematics_PointOnPlanarCurvePairWithRange, anent, ent);
+ RWStepKinematics_RWPointOnPlanarCurvePairWithRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 752:
+ {
+ DeclareAndCast(StepKinematics_PointOnSurfacePair, anent, ent);
+ RWStepKinematics_RWPointOnSurfacePair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 753:
+ {
+ DeclareAndCast(StepKinematics_PointOnSurfacePairValue, anent, ent);
+ RWStepKinematics_RWPointOnSurfacePairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 754:
+ {
+ DeclareAndCast(StepKinematics_PointOnSurfacePairWithRange, anent, ent);
+ RWStepKinematics_RWPointOnSurfacePairWithRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 755:
+ {
+ DeclareAndCast(StepKinematics_PrismaticPair, anent, ent);
+ RWStepKinematics_RWPrismaticPair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 756:
+ {
+ DeclareAndCast(StepKinematics_PrismaticPairValue, anent, ent);
+ RWStepKinematics_RWPrismaticPairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 757:
+ {
+ DeclareAndCast(StepKinematics_PrismaticPairWithRange, anent, ent);
+ RWStepKinematics_RWPrismaticPairWithRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 758:
+ {
+ DeclareAndCast(StepKinematics_ProductDefinitionKinematics, anent, ent);
+ RWStepKinematics_RWProductDefinitionKinematics tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 759:
+ {
+ DeclareAndCast(StepKinematics_ProductDefinitionRelationshipKinematics, anent, ent);
+ RWStepKinematics_RWProductDefinitionRelationshipKinematics tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 760:
+ {
+ DeclareAndCast(StepKinematics_RackAndPinionPair, anent, ent);
+ RWStepKinematics_RWRackAndPinionPair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 761:
+ {
+ DeclareAndCast(StepKinematics_RackAndPinionPairValue, anent, ent);
+ RWStepKinematics_RWRackAndPinionPairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 762:
+ {
+ DeclareAndCast(StepKinematics_RackAndPinionPairWithRange, anent, ent);
+ RWStepKinematics_RWRackAndPinionPairWithRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 763:
+ {
+ DeclareAndCast(StepKinematics_RevolutePair, anent, ent);
+ RWStepKinematics_RWRevolutePair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 764:
+ {
+ DeclareAndCast(StepKinematics_RevolutePairValue, anent, ent);
+ RWStepKinematics_RWRevolutePairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 765:
+ {
+ DeclareAndCast(StepKinematics_RevolutePairWithRange, anent, ent);
+ RWStepKinematics_RWRevolutePairWithRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 766:
+ {
+ DeclareAndCast(StepKinematics_RollingCurvePair, anent, ent);
+ RWStepKinematics_RWRollingCurvePair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 767:
+ {
+ DeclareAndCast(StepKinematics_RollingCurvePairValue, anent, ent);
+ RWStepKinematics_RWRollingCurvePairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 768:
+ {
+ DeclareAndCast(StepKinematics_RollingSurfacePair, anent, ent);
+ RWStepKinematics_RWRollingSurfacePair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 769:
+ {
+ DeclareAndCast(StepKinematics_RollingSurfacePairValue, anent, ent);
+ RWStepKinematics_RWRollingSurfacePairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 770:
+ {
+ DeclareAndCast(StepKinematics_ScrewPair, anent, ent);
+ RWStepKinematics_RWScrewPair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 771:
+ {
+ DeclareAndCast(StepKinematics_ScrewPairValue, anent, ent);
+ RWStepKinematics_RWScrewPairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 772:
+ {
+ DeclareAndCast(StepKinematics_ScrewPairWithRange, anent, ent);
+ RWStepKinematics_RWScrewPairWithRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 773:
+ {
+ DeclareAndCast(StepKinematics_SlidingCurvePair, anent, ent);
+ RWStepKinematics_RWSlidingCurvePair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 774:
+ {
+ DeclareAndCast(StepKinematics_SlidingCurvePairValue, anent, ent);
+ RWStepKinematics_RWSlidingCurvePairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 775:
+ {
+ DeclareAndCast(StepKinematics_SlidingSurfacePair, anent, ent);
+ RWStepKinematics_RWSlidingSurfacePair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 776:
+ {
+ DeclareAndCast(StepKinematics_SlidingSurfacePairValue, anent, ent);
+ RWStepKinematics_RWSlidingSurfacePairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 777:
+ {
+ DeclareAndCast(StepKinematics_SphericalPair, anent, ent);
+ RWStepKinematics_RWSphericalPair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 778:
+ {
+ DeclareAndCast(StepKinematics_SphericalPairValue, anent, ent);
+ RWStepKinematics_RWSphericalPairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 779:
+ {
+ DeclareAndCast(StepKinematics_SphericalPairWithPin, anent, ent);
+ RWStepKinematics_RWSphericalPairWithPin tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 780:
+ {
+ DeclareAndCast(StepKinematics_SphericalPairWithPinAndRange, anent, ent);
+ RWStepKinematics_RWSphericalPairWithPinAndRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 781:
+ {
+ DeclareAndCast(StepKinematics_SphericalPairWithRange, anent, ent);
+ RWStepKinematics_RWSphericalPairWithRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 782:
+ {
+ DeclareAndCast(StepKinematics_SurfacePairWithRange, anent, ent);
+ RWStepKinematics_RWSurfacePairWithRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 783:
+ {
+ DeclareAndCast(StepKinematics_UnconstrainedPair, anent, ent);
+ RWStepKinematics_RWUnconstrainedPair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 784:
+ {
+ DeclareAndCast(StepKinematics_UnconstrainedPairValue, anent, ent);
+ RWStepKinematics_RWUnconstrainedPairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 785:
+ {
+ DeclareAndCast(StepKinematics_UniversalPair, anent, ent);
+ RWStepKinematics_RWUniversalPair tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 786:
+ {
+ DeclareAndCast(StepKinematics_UniversalPairValue, anent, ent);
+ RWStepKinematics_RWUniversalPairValue tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+ case 787:
+ {
+ DeclareAndCast(StepKinematics_UniversalPairWithRange, anent, ent);
+ RWStepKinematics_RWUniversalPairWithRange tool;
+ tool.ReadStep(data, num, ach, anent);
+ }
+ break;
+
default:
tool.WriteStep(SW, anent);
}
break;
+ case 720:
+ {
+ DeclareAndCast(StepRepr_RepresentationContextReference, anent, ent);
+ RWStepRepr_RWRepresentationContextReference tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 721:
+ {
+ DeclareAndCast(StepRepr_RepresentationReference, anent, ent);
+ RWStepRepr_RWRepresentationReference tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 722:
+ {
+ DeclareAndCast(StepKinematics_SuParameters, anent, ent);
+ RWStepKinematics_RWSuParameters tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 723:
+ {
+ DeclareAndCast(StepKinematics_RotationAboutDirection, anent, ent);
+ RWStepKinematics_RWRotationAboutDirection tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 724:
+ {
+ DeclareAndCast(StepKinematics_KinematicJoint, anent, ent);
+ RWStepKinematics_RWKinematicJoint tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 725:
+ {
+ DeclareAndCast(StepKinematics_ActuatedKinematicPair, anent, ent);
+ RWStepKinematics_RWActuatedKinematicPair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 726:
+ {
+ DeclareAndCast(StepKinematics_ContextDependentKinematicLinkRepresentation, anent, ent);
+ RWStepKinematics_RWContextDependentKinematicLinkRepresentation tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 727:
+ {
+ DeclareAndCast(StepKinematics_CylindricalPair, anent, ent);
+ RWStepKinematics_RWCylindricalPair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 728:
+ {
+ DeclareAndCast(StepKinematics_CylindricalPairValue, anent, ent);
+ RWStepKinematics_RWCylindricalPairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 729:
+ {
+ DeclareAndCast(StepKinematics_CylindricalPairWithRange, anent, ent);
+ RWStepKinematics_RWCylindricalPairWithRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 730:
+ {
+ DeclareAndCast(StepKinematics_FullyConstrainedPair, anent, ent);
+ RWStepKinematics_RWFullyConstrainedPair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 731:
+ {
+ DeclareAndCast(StepKinematics_GearPair, anent, ent);
+ RWStepKinematics_RWGearPair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 732:
+ {
+ DeclareAndCast(StepKinematics_GearPairValue, anent, ent);
+ RWStepKinematics_RWGearPairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 733:
+ {
+ DeclareAndCast(StepKinematics_GearPairWithRange, anent, ent);
+ RWStepKinematics_RWGearPairWithRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 734:
+ {
+ DeclareAndCast(StepKinematics_HomokineticPair, anent, ent);
+ RWStepKinematics_RWHomokineticPair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 735:
+ {
+ DeclareAndCast(StepKinematics_KinematicLink, anent, ent);
+ RWStepKinematics_RWKinematicLink tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 736:
+ {
+ DeclareAndCast(StepKinematics_KinematicLinkRepresentationAssociation, anent, ent);
+ RWStepKinematics_RWKinematicLinkRepresentationAssociation tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 737:
+ {
+ DeclareAndCast(StepKinematics_KinematicPropertyMechanismRepresentation, anent, ent);
+ RWStepKinematics_RWKinematicPropertyMechanismRepresentation tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 738:
+ {
+ DeclareAndCast(StepKinematics_KinematicTopologyStructure, anent, ent);
+ RWStepKinematics_RWKinematicTopologyStructure tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 739:
+ {
+ DeclareAndCast(StepKinematics_LowOrderKinematicPair, anent, ent);
+ RWStepKinematics_RWLowOrderKinematicPair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 740:
+ {
+ DeclareAndCast(StepKinematics_LowOrderKinematicPairValue, anent, ent);
+ RWStepKinematics_RWLowOrderKinematicPairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 741:
+ {
+ DeclareAndCast(StepKinematics_LowOrderKinematicPairWithRange, anent, ent);
+ RWStepKinematics_RWLowOrderKinematicPairWithRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 742:
+ {
+ DeclareAndCast(StepKinematics_MechanismRepresentation, anent, ent);
+ RWStepKinematics_RWMechanismRepresentation tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 743:
+ {
+ DeclareAndCast(StepKinematics_OrientedJoint, anent, ent);
+ RWStepKinematics_RWOrientedJoint tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 744:
+ {
+ DeclareAndCast(StepKinematics_PlanarCurvePair, anent, ent);
+ RWStepKinematics_RWPlanarCurvePair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 745:
+ {
+ DeclareAndCast(StepKinematics_PlanarCurvePairRange, anent, ent);
+ RWStepKinematics_RWPlanarCurvePairRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 746:
+ {
+ DeclareAndCast(StepKinematics_PlanarPair, anent, ent);
+ RWStepKinematics_RWPlanarPair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 747:
+ {
+ DeclareAndCast(StepKinematics_PlanarPairValue, anent, ent);
+ RWStepKinematics_RWPlanarPairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 748:
+ {
+ DeclareAndCast(StepKinematics_PlanarPairWithRange, anent, ent);
+ RWStepKinematics_RWPlanarPairWithRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 749:
+ {
+ DeclareAndCast(StepKinematics_PointOnPlanarCurvePair, anent, ent);
+ RWStepKinematics_RWPointOnPlanarCurvePair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 750:
+ {
+ DeclareAndCast(StepKinematics_PointOnPlanarCurvePairValue, anent, ent);
+ RWStepKinematics_RWPointOnPlanarCurvePairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 751:
+ {
+ DeclareAndCast(StepKinematics_PointOnPlanarCurvePairWithRange, anent, ent);
+ RWStepKinematics_RWPointOnPlanarCurvePairWithRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 752:
+ {
+ DeclareAndCast(StepKinematics_PointOnSurfacePair, anent, ent);
+ RWStepKinematics_RWPointOnSurfacePair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 753:
+ {
+ DeclareAndCast(StepKinematics_PointOnSurfacePairValue, anent, ent);
+ RWStepKinematics_RWPointOnSurfacePairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 754:
+ {
+ DeclareAndCast(StepKinematics_PointOnSurfacePairWithRange, anent, ent);
+ RWStepKinematics_RWPointOnSurfacePairWithRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 755:
+ {
+ DeclareAndCast(StepKinematics_PrismaticPair, anent, ent);
+ RWStepKinematics_RWPrismaticPair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 756:
+ {
+ DeclareAndCast(StepKinematics_PrismaticPairValue, anent, ent);
+ RWStepKinematics_RWPrismaticPairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 757:
+ {
+ DeclareAndCast(StepKinematics_PrismaticPairWithRange, anent, ent);
+ RWStepKinematics_RWPrismaticPairWithRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 758:
+ {
+ DeclareAndCast(StepKinematics_ProductDefinitionKinematics, anent, ent);
+ RWStepKinematics_RWProductDefinitionKinematics tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 759:
+ {
+ DeclareAndCast(StepKinematics_ProductDefinitionRelationshipKinematics, anent, ent);
+ RWStepKinematics_RWProductDefinitionRelationshipKinematics tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 760:
+ {
+ DeclareAndCast(StepKinematics_RackAndPinionPair, anent, ent);
+ RWStepKinematics_RWRackAndPinionPair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 761:
+ {
+ DeclareAndCast(StepKinematics_RackAndPinionPairValue, anent, ent);
+ RWStepKinematics_RWRackAndPinionPairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 762:
+ {
+ DeclareAndCast(StepKinematics_RackAndPinionPairWithRange, anent, ent);
+ RWStepKinematics_RWRackAndPinionPairWithRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 763:
+ {
+ DeclareAndCast(StepKinematics_RevolutePair, anent, ent);
+ RWStepKinematics_RWRevolutePair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 764:
+ {
+ DeclareAndCast(StepKinematics_RevolutePairValue, anent, ent);
+ RWStepKinematics_RWRevolutePairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 765:
+ {
+ DeclareAndCast(StepKinematics_RevolutePairWithRange, anent, ent);
+ RWStepKinematics_RWRevolutePairWithRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 766:
+ {
+ DeclareAndCast(StepKinematics_RollingCurvePair, anent, ent);
+ RWStepKinematics_RWRollingCurvePair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 767:
+ {
+ DeclareAndCast(StepKinematics_RollingCurvePairValue, anent, ent);
+ RWStepKinematics_RWRollingCurvePairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 768:
+ {
+ DeclareAndCast(StepKinematics_RollingSurfacePair, anent, ent);
+ RWStepKinematics_RWRollingSurfacePair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 769:
+ {
+ DeclareAndCast(StepKinematics_RollingSurfacePairValue, anent, ent);
+ RWStepKinematics_RWRollingSurfacePairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 770:
+ {
+ DeclareAndCast(StepKinematics_ScrewPair, anent, ent);
+ RWStepKinematics_RWScrewPair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 771:
+ {
+ DeclareAndCast(StepKinematics_ScrewPairValue, anent, ent);
+ RWStepKinematics_RWScrewPairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 772:
+ {
+ DeclareAndCast(StepKinematics_ScrewPairWithRange, anent, ent);
+ RWStepKinematics_RWScrewPairWithRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 773:
+ {
+ DeclareAndCast(StepKinematics_SlidingCurvePair, anent, ent);
+ RWStepKinematics_RWSlidingCurvePair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 774:
+ {
+ DeclareAndCast(StepKinematics_SlidingCurvePairValue, anent, ent);
+ RWStepKinematics_RWSlidingCurvePairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 775:
+ {
+ DeclareAndCast(StepKinematics_SlidingSurfacePair, anent, ent);
+ RWStepKinematics_RWSlidingSurfacePair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 776:
+ {
+ DeclareAndCast(StepKinematics_SlidingSurfacePairValue, anent, ent);
+ RWStepKinematics_RWSlidingSurfacePairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 777:
+ {
+ DeclareAndCast(StepKinematics_SphericalPair, anent, ent);
+ RWStepKinematics_RWSphericalPair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 778:
+ {
+ DeclareAndCast(StepKinematics_SphericalPairValue, anent, ent);
+ RWStepKinematics_RWSphericalPairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 779:
+ {
+ DeclareAndCast(StepKinematics_SphericalPairWithPin, anent, ent);
+ RWStepKinematics_RWSphericalPairWithPin tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 780:
+ {
+ DeclareAndCast(StepKinematics_SphericalPairWithPinAndRange, anent, ent);
+ RWStepKinematics_RWSphericalPairWithPinAndRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 781:
+ {
+ DeclareAndCast(StepKinematics_SphericalPairWithRange, anent, ent);
+ RWStepKinematics_RWSphericalPairWithRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 782:
+ {
+ DeclareAndCast(StepKinematics_SurfacePairWithRange, anent, ent);
+ RWStepKinematics_RWSurfacePairWithRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 783:
+ {
+ DeclareAndCast(StepKinematics_UnconstrainedPair, anent, ent);
+ RWStepKinematics_RWUnconstrainedPair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 784:
+ {
+ DeclareAndCast(StepKinematics_UnconstrainedPairValue, anent, ent);
+ RWStepKinematics_RWUnconstrainedPairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 785:
+ {
+ DeclareAndCast(StepKinematics_UniversalPair, anent, ent);
+ RWStepKinematics_RWUniversalPair tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 786:
+ {
+ DeclareAndCast(StepKinematics_UniversalPairValue, anent, ent);
+ RWStepKinematics_RWUniversalPairValue tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+ case 787:
+ {
+ DeclareAndCast(StepKinematics_UniversalPairWithRange, anent, ent);
+ RWStepKinematics_RWUniversalPairWithRange tool;
+ tool.WriteStep(SW, anent);
+ }
+ break;
+
default:
return;
--- /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_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_RWLowOrderKinematicPair.cxx
+RWStepKinematics_RWLowOrderKinematicPair.hxx
+RWStepKinematics_RWLowOrderKinematicPairValue.cxx
+RWStepKinematics_RWLowOrderKinematicPairValue.hxx
+RWStepKinematics_RWLowOrderKinematicPairWithRange.cxx
+RWStepKinematics_RWLowOrderKinematicPairWithRange.hxx
+RWStepKinematics_RWMechanismRepresentation.cxx
+RWStepKinematics_RWMechanismRepresentation.hxx
+RWStepKinematics_RWOrientedJoint.cxx
+RWStepKinematics_RWOrientedJoint.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_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_RWSuParameters.cxx
+RWStepKinematics_RWSuParameters.hxx
+RWStepKinematics_RWSurfacePairWithRange.cxx
+RWStepKinematics_RWSurfacePairWithRange.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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWActuatedKinematicPair.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_ActuatedKinematicPair)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,12,ach,"actuated_kinematic_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Own fields of ActuatedKinematicPair
+
+ StepKinematics_ActuatedDirection aTX = StepKinematics_adNotActuated;
+ Standard_Boolean hasTX = Standard_True;
+ if ( data->IsParamDefined (num,7) ) {
+ if (data->ParamType (num, 7) == Interface_ParamEnum) {
+ Standard_CString text = data->ParamCValue(num, 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 ach->AddFail("Parameter #7 (t_x) has not allowed value");
+ }
+ else ach->AddFail("Parameter #7 (t_x) is not enumeration");
+ }
+ else {
+ hasTX = Standard_False;
+ }
+
+ StepKinematics_ActuatedDirection aTY = StepKinematics_adNotActuated;
+ Standard_Boolean hasTY = Standard_True;
+ if ( data->IsParamDefined (num,8) ) {
+ if (data->ParamType (num, 8) == Interface_ParamEnum) {
+ Standard_CString text = data->ParamCValue(num, 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 ach->AddFail("Parameter #8 (t_y) has not allowed value");
+ }
+ else ach->AddFail("Parameter #8 (t_y) is not enumeration");
+ }
+ else {
+ hasTY = Standard_False;
+ }
+
+ StepKinematics_ActuatedDirection aTZ = StepKinematics_adNotActuated;
+ Standard_Boolean hasTZ = Standard_True;
+ if ( data->IsParamDefined (num,9) ) {
+ if (data->ParamType (num, 9) == Interface_ParamEnum) {
+ Standard_CString text = data->ParamCValue(num, 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 ach->AddFail("Parameter #9 (t_z) has not allowed value");
+ }
+ else ach->AddFail("Parameter #9 (t_z) is not enumeration");
+ }
+ else {
+ hasTZ = Standard_False;
+ }
+
+ StepKinematics_ActuatedDirection aRX = StepKinematics_adNotActuated;
+ Standard_Boolean hasRX = Standard_True;
+ if ( data->IsParamDefined (num,10) ) {
+ if (data->ParamType (num, 10) == Interface_ParamEnum) {
+ Standard_CString text = data->ParamCValue(num, 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 ach->AddFail("Parameter #10 (r_x) has not allowed value");
+ }
+ else ach->AddFail("Parameter #10 (r_x) is not enumeration");
+ }
+ else {
+ hasRX = Standard_False;
+ }
+
+ StepKinematics_ActuatedDirection aRY = StepKinematics_adNotActuated;
+ Standard_Boolean hasRY = Standard_True;
+ if ( data->IsParamDefined (num,11) ) {
+ if (data->ParamType (num, 11) == Interface_ParamEnum) {
+ Standard_CString text = data->ParamCValue(num, 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 ach->AddFail("Parameter #11 (r_y) has not allowed value");
+ }
+ else ach->AddFail("Parameter #11 (r_y) is not enumeration");
+ }
+ else {
+ hasRY = Standard_False;
+ }
+
+ StepKinematics_ActuatedDirection aRZ = StepKinematics_adNotActuated;
+ Standard_Boolean hasRZ = Standard_True;
+ if ( data->IsParamDefined (num,12) ) {
+ if (data->ParamType (num, 12) == Interface_ParamEnum) {
+ Standard_CString text = data->ParamCValue(num, 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 ach->AddFail("Parameter #12 (r_z) has not allowed value");
+ }
+ else ach->AddFail("Parameter #12 (r_z) is not enumeration");
+ }
+ else {
+ hasRZ = Standard_False;
+ }
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_ActuatedKinematicPair)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of ActuatedKinematicPair
+
+ if ( ent->HasTX() ) {
+ switch (ent->TX()) {
+ case StepKinematics_adBidirectional: SW.SendEnum (".BIDIRECTIONAL."); break;
+ case StepKinematics_adPositiveOnly: SW.SendEnum (".POSITIVE_ONLY."); break;
+ case StepKinematics_adNegativeOnly: SW.SendEnum (".NEGATIVE_ONLY."); break;
+ case StepKinematics_adNotActuated: SW.SendEnum (".NOT_ACTUATED."); break;
+ }
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasTY() ) {
+ switch (ent->TY()) {
+ case StepKinematics_adBidirectional: SW.SendEnum (".BIDIRECTIONAL."); break;
+ case StepKinematics_adPositiveOnly: SW.SendEnum (".POSITIVE_ONLY."); break;
+ case StepKinematics_adNegativeOnly: SW.SendEnum (".NEGATIVE_ONLY."); break;
+ case StepKinematics_adNotActuated: SW.SendEnum (".NOT_ACTUATED."); break;
+ }
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasTZ() ) {
+ switch (ent->TZ()) {
+ case StepKinematics_adBidirectional: SW.SendEnum (".BIDIRECTIONAL."); break;
+ case StepKinematics_adPositiveOnly: SW.SendEnum (".POSITIVE_ONLY."); break;
+ case StepKinematics_adNegativeOnly: SW.SendEnum (".NEGATIVE_ONLY."); break;
+ case StepKinematics_adNotActuated: SW.SendEnum (".NOT_ACTUATED."); break;
+ }
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasRX() ) {
+ switch (ent->RX()) {
+ case StepKinematics_adBidirectional: SW.SendEnum (".BIDIRECTIONAL."); break;
+ case StepKinematics_adPositiveOnly: SW.SendEnum (".POSITIVE_ONLY."); break;
+ case StepKinematics_adNegativeOnly: SW.SendEnum (".NEGATIVE_ONLY."); break;
+ case StepKinematics_adNotActuated: SW.SendEnum (".NOT_ACTUATED."); break;
+ }
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasRY() ) {
+ switch (ent->RY()) {
+ case StepKinematics_adBidirectional: SW.SendEnum (".BIDIRECTIONAL."); break;
+ case StepKinematics_adPositiveOnly: SW.SendEnum (".POSITIVE_ONLY."); break;
+ case StepKinematics_adNegativeOnly: SW.SendEnum (".NEGATIVE_ONLY."); break;
+ case StepKinematics_adNotActuated: SW.SendEnum (".NOT_ACTUATED."); break;
+ }
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasRZ() ) {
+ switch (ent->RZ()) {
+ case StepKinematics_adBidirectional: SW.SendEnum (".BIDIRECTIONAL."); break;
+ case StepKinematics_adPositiveOnly: SW.SendEnum (".POSITIVE_ONLY."); break;
+ case StepKinematics_adNegativeOnly: SW.SendEnum (".NEGATIVE_ONLY."); break;
+ case StepKinematics_adNotActuated: SW.SendEnum (".NOT_ACTUATED."); break;
+ }
+ }
+ else SW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWActuatedKinematicPair::Share (const Handle(StepKinematics_ActuatedKinematicPair)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Own fields of ActuatedKinematicPair
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_ActuatedKinematicPair)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_ActuatedKinematicPair)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_ActuatedKinematicPair)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWActuatedKinematicPair_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWContextDependentKinematicLinkRepresentation.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_ContextDependentKinematicLinkRepresentation)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,2,ach,"context_dependent_kinematic_link_representation") ) return;
+
+ // Own fields of ContextDependentKinematicLinkRepresentation
+
+ Handle(StepKinematics_KinematicLinkRepresentationAssociation) aRepresentationRelation;
+ data->ReadEntity (num, 1, "representation_relation", ach, STANDARD_TYPE(StepKinematics_KinematicLinkRepresentationAssociation), aRepresentationRelation);
+
+ Handle(StepKinematics_ProductDefinitionRelationshipKinematics) aRepresentedProductRelation;
+ data->ReadEntity (num, 2, "represented_product_relation", ach, STANDARD_TYPE(StepKinematics_ProductDefinitionRelationshipKinematics), aRepresentedProductRelation);
+
+ // Initialize entity
+ ent->Init(aRepresentationRelation,
+ aRepresentedProductRelation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWContextDependentKinematicLinkRepresentation::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_ContextDependentKinematicLinkRepresentation)& ent) const
+{
+
+ // Own fields of ContextDependentKinematicLinkRepresentation
+
+ SW.Send (ent->RepresentationRelation());
+
+ SW.Send (ent->RepresentedProductRelation());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWContextDependentKinematicLinkRepresentation::Share (const Handle(StepKinematics_ContextDependentKinematicLinkRepresentation)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Own fields of ContextDependentKinematicLinkRepresentation
+
+ iter.AddItem (ent->RepresentationRelation());
+
+ iter.AddItem (ent->RepresentedProductRelation());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_ContextDependentKinematicLinkRepresentation)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_ContextDependentKinematicLinkRepresentation)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_ContextDependentKinematicLinkRepresentation)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWContextDependentKinematicLinkRepresentation_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWCylindricalPair.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_CylindricalPair)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,12,ach,"cylindrical_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ data->ReadBoolean (num, 7, "low_order_kinematic_pair.t_x", ach, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ data->ReadBoolean (num, 8, "low_order_kinematic_pair.t_y", ach, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ data->ReadBoolean (num, 9, "low_order_kinematic_pair.t_z", ach, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ data->ReadBoolean (num, 10, "low_order_kinematic_pair.r_x", ach, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ data->ReadBoolean (num, 11, "low_order_kinematic_pair.r_y", ach, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ data->ReadBoolean (num, 12, "low_order_kinematic_pair.r_z", ach, aLowOrderKinematicPair_RZ);
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_CylindricalPair)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ SW.SendBoolean (ent->TX());
+
+ SW.SendBoolean (ent->TY());
+
+ SW.SendBoolean (ent->TZ());
+
+ SW.SendBoolean (ent->RX());
+
+ SW.SendBoolean (ent->RY());
+
+ SW.SendBoolean (ent->RZ());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWCylindricalPair::Share (const Handle(StepKinematics_CylindricalPair)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_CylindricalPair)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_CylindricalPair)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_CylindricalPair)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWCylindricalPair_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWCylindricalPairValue.hxx>
+#include <StepKinematics_CylindricalPairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWCylindricalPairValue
+//purpose :
+//=======================================================================
+
+RWStepKinematics_RWCylindricalPairValue::RWStepKinematics_RWCylindricalPairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWCylindricalPairValue::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_CylindricalPairValue)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,2,ach,"cylindrical_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ data->ReadEntity (num, 2, "pair_value.applies_to_pair", ach, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Initialize entity
+ ent->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWCylindricalPairValue::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_CylindricalPairValue)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Own fields of PairValue
+
+ SW.Send (ent->AppliesToPair());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWCylindricalPairValue::Share (const Handle(StepKinematics_CylindricalPairValue)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (ent->StepKinematics_PairValue::AppliesToPair());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_CylindricalPairValue)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_CylindricalPairValue)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_CylindricalPairValue)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWCylindricalPairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWCylindricalPairWithRange.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_CylindricalPairWithRange)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,16,ach,"cylindrical_pair_with_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ data->ReadBoolean (num, 7, "low_order_kinematic_pair.t_x", ach, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ data->ReadBoolean (num, 8, "low_order_kinematic_pair.t_y", ach, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ data->ReadBoolean (num, 9, "low_order_kinematic_pair.t_z", ach, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ data->ReadBoolean (num, 10, "low_order_kinematic_pair.r_x", ach, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ data->ReadBoolean (num, 11, "low_order_kinematic_pair.r_y", ach, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ data->ReadBoolean (num, 12, "low_order_kinematic_pair.r_z", ach, aLowOrderKinematicPair_RZ);
+
+ // Own fields of CylindricalPairWithRange
+
+ Standard_Real aLowerLimitActualTranslation;
+ Standard_Boolean hasLowerLimitActualTranslation = Standard_True;
+ if ( data->IsParamDefined (num,13) ) {
+ data->ReadReal (num, 13, "lower_limit_actual_translation", ach, aLowerLimitActualTranslation);
+ }
+ else {
+ hasLowerLimitActualTranslation = Standard_False;
+ aLowerLimitActualTranslation = 0;
+ }
+
+ Standard_Real aUpperLimitActualTranslation;
+ Standard_Boolean hasUpperLimitActualTranslation = Standard_True;
+ if ( data->IsParamDefined (num,14) ) {
+ data->ReadReal (num, 14, "upper_limit_actual_translation", ach, aUpperLimitActualTranslation);
+ }
+ else {
+ hasUpperLimitActualTranslation = Standard_False;
+ aUpperLimitActualTranslation = 0;
+ }
+
+ Standard_Real aLowerLimitActualRotation;
+ Standard_Boolean hasLowerLimitActualRotation = Standard_True;
+ if ( data->IsParamDefined (num,15) ) {
+ data->ReadReal (num, 15, "lower_limit_actual_rotation", ach, aLowerLimitActualRotation);
+ }
+ else {
+ hasLowerLimitActualRotation = Standard_False;
+ aLowerLimitActualRotation = 0;
+ }
+
+ Standard_Real aUpperLimitActualRotation;
+ Standard_Boolean hasUpperLimitActualRotation = Standard_True;
+ if ( data->IsParamDefined (num,16) ) {
+ data->ReadReal (num, 16, "upper_limit_actual_rotation", ach, aUpperLimitActualRotation);
+ }
+ else {
+ hasUpperLimitActualRotation = Standard_False;
+ aUpperLimitActualRotation = 0;
+ }
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_CylindricalPairWithRange)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ SW.SendBoolean (ent->TX());
+
+ SW.SendBoolean (ent->TY());
+
+ SW.SendBoolean (ent->TZ());
+
+ SW.SendBoolean (ent->RX());
+
+ SW.SendBoolean (ent->RY());
+
+ SW.SendBoolean (ent->RZ());
+
+ // Own fields of CylindricalPairWithRange
+
+ if ( ent->HasLowerLimitActualTranslation() ) {
+ SW.Send (ent->LowerLimitActualTranslation());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitActualTranslation() ) {
+ SW.Send (ent->UpperLimitActualTranslation());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasLowerLimitActualRotation() ) {
+ SW.Send (ent->LowerLimitActualRotation());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitActualRotation() ) {
+ SW.Send (ent->UpperLimitActualRotation());
+ }
+ else SW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWCylindricalPairWithRange::Share (const Handle(StepKinematics_CylindricalPairWithRange)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+
+ // Own fields of CylindricalPairWithRange
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_CylindricalPairWithRange)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_CylindricalPairWithRange)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_CylindricalPairWithRange)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWCylindricalPairWithRange_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWFullyConstrainedPair.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_FullyConstrainedPair)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,12,ach,"fully_constrained_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ data->ReadBoolean (num, 7, "low_order_kinematic_pair.t_x", ach, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ data->ReadBoolean (num, 8, "low_order_kinematic_pair.t_y", ach, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ data->ReadBoolean (num, 9, "low_order_kinematic_pair.t_z", ach, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ data->ReadBoolean (num, 10, "low_order_kinematic_pair.r_x", ach, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ data->ReadBoolean (num, 11, "low_order_kinematic_pair.r_y", ach, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ data->ReadBoolean (num, 12, "low_order_kinematic_pair.r_z", ach, aLowOrderKinematicPair_RZ);
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_FullyConstrainedPair)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ SW.SendBoolean (ent->TX());
+
+ SW.SendBoolean (ent->TY());
+
+ SW.SendBoolean (ent->TZ());
+
+ SW.SendBoolean (ent->RX());
+
+ SW.SendBoolean (ent->RY());
+
+ SW.SendBoolean (ent->RZ());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWFullyConstrainedPair::Share (const Handle(StepKinematics_FullyConstrainedPair)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_FullyConstrainedPair)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_FullyConstrainedPair)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_FullyConstrainedPair)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWFullyConstrainedPair_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWGearPair.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_GearPair)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,11,ach,"gear_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Own fields of GearPair
+
+ Standard_Real aRadiusFirstLink;
+ data->ReadReal (num, 7, "radius_first_link", ach, aRadiusFirstLink);
+
+ Standard_Real aRadiusSecondLink;
+ data->ReadReal (num, 8, "radius_second_link", ach, aRadiusSecondLink);
+
+ Standard_Real aBevel;
+ data->ReadReal (num, 9, "bevel", ach, aBevel);
+
+ Standard_Real aHelicalAngle;
+ data->ReadReal (num, 10, "helical_angle", ach, aHelicalAngle);
+
+ Standard_Real aGearRatio;
+ data->ReadReal (num, 11, "gear_ratio", ach, aGearRatio);
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_GearPair)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of GearPair
+
+ SW.Send (ent->RadiusFirstLink());
+
+ SW.Send (ent->RadiusSecondLink());
+
+ SW.Send (ent->Bevel());
+
+ SW.Send (ent->HelicalAngle());
+
+ SW.Send (ent->GearRatio());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWGearPair::Share (const Handle(StepKinematics_GearPair)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Own fields of GearPair
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_GearPair)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_GearPair)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_GearPair)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWGearPair_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWGearPairValue.hxx>
+#include <StepKinematics_GearPairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWGearPairValue
+//purpose :
+//=======================================================================
+
+RWStepKinematics_RWGearPairValue::RWStepKinematics_RWGearPairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWGearPairValue::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_GearPairValue)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,2,ach,"gear_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ data->ReadEntity (num, 2, "pair_value.applies_to_pair", ach, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Initialize entity
+ ent->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWGearPairValue::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_GearPairValue)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Own fields of PairValue
+
+ SW.Send (ent->AppliesToPair());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWGearPairValue::Share (const Handle(StepKinematics_GearPairValue)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (ent->StepKinematics_PairValue::AppliesToPair());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_GearPairValue)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_GearPairValue)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_GearPairValue)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWGearPairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWGearPairWithRange.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_GearPairWithRange)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,13,ach,"gear_pair_with_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of GearPair
+
+ Standard_Real aGearPair_RadiusFirstLink;
+ data->ReadReal (num, 7, "gear_pair.radius_first_link", ach, aGearPair_RadiusFirstLink);
+
+ Standard_Real aGearPair_RadiusSecondLink;
+ data->ReadReal (num, 8, "gear_pair.radius_second_link", ach, aGearPair_RadiusSecondLink);
+
+ Standard_Real aGearPair_Bevel;
+ data->ReadReal (num, 9, "gear_pair.bevel", ach, aGearPair_Bevel);
+
+ Standard_Real aGearPair_HelicalAngle;
+ data->ReadReal (num, 10, "gear_pair.helical_angle", ach, aGearPair_HelicalAngle);
+
+ Standard_Real aGearPair_GearRatio;
+ data->ReadReal (num, 11, "gear_pair.gear_ratio", ach, aGearPair_GearRatio);
+
+ // Own fields of GearPairWithRange
+
+ Standard_Real aLowerLimitActualRotation1;
+ Standard_Boolean hasLowerLimitActualRotation1 = Standard_True;
+ if ( data->IsParamDefined (num,12) ) {
+ data->ReadReal (num, 12, "lower_limit_actual_rotation1", ach, aLowerLimitActualRotation1);
+ }
+ else {
+ hasLowerLimitActualRotation1 = Standard_False;
+ aLowerLimitActualRotation1 = 0;
+ }
+
+ Standard_Real aUpperLimitActualRotation1;
+ Standard_Boolean hasUpperLimitActualRotation1 = Standard_True;
+ if ( data->IsParamDefined (num,13) ) {
+ data->ReadReal (num, 13, "upper_limit_actual_rotation1", ach, aUpperLimitActualRotation1);
+ }
+ else {
+ hasUpperLimitActualRotation1 = Standard_False;
+ aUpperLimitActualRotation1 = 0;
+ }
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_GearPairWithRange)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of GearPair
+
+ SW.Send (ent->RadiusFirstLink());
+
+ SW.Send (ent->RadiusSecondLink());
+
+ SW.Send (ent->Bevel());
+
+ SW.Send (ent->HelicalAngle());
+
+ SW.Send (ent->GearRatio());
+
+ // Own fields of GearPairWithRange
+
+ if ( ent->HasLowerLimitActualRotation1() ) {
+ SW.Send (ent->LowerLimitActualRotation1());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitActualRotation1() ) {
+ SW.Send (ent->UpperLimitActualRotation1());
+ }
+ else SW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWGearPairWithRange::Share (const Handle(StepKinematics_GearPairWithRange)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of GearPair
+
+ // Own fields of GearPairWithRange
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_GearPairWithRange)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_GearPairWithRange)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_GearPairWithRange)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWGearPairWithRange_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWHomokineticPair.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_HomokineticPair)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,13,ach,"homokinetic_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ data->ReadBoolean (num, 7, "low_order_kinematic_pair.t_x", ach, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ data->ReadBoolean (num, 8, "low_order_kinematic_pair.t_y", ach, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ data->ReadBoolean (num, 9, "low_order_kinematic_pair.t_z", ach, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ data->ReadBoolean (num, 10, "low_order_kinematic_pair.r_x", ach, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ data->ReadBoolean (num, 11, "low_order_kinematic_pair.r_y", ach, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ data->ReadBoolean (num, 12, "low_order_kinematic_pair.r_z", ach, aLowOrderKinematicPair_RZ);
+
+ // Inherited fields of UniversalPair
+
+ Standard_Real aUniversalPair_InputSkewAngle;
+ Standard_Boolean hasUniversalPair_InputSkewAngle = Standard_True;
+ if ( data->IsParamDefined (num,13) ) {
+ data->ReadReal (num, 13, "universal_pair.input_skew_angle", ach, aUniversalPair_InputSkewAngle);
+ }
+ else {
+ hasUniversalPair_InputSkewAngle = Standard_False;
+ aUniversalPair_InputSkewAngle = 0;
+ }
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_HomokineticPair)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ SW.SendBoolean (ent->TX());
+
+ SW.SendBoolean (ent->TY());
+
+ SW.SendBoolean (ent->TZ());
+
+ SW.SendBoolean (ent->RX());
+
+ SW.SendBoolean (ent->RY());
+
+ SW.SendBoolean (ent->RZ());
+
+ // Own fields of UniversalPair
+
+ if ( ent->HasInputSkewAngle() ) {
+ SW.Send (ent->InputSkewAngle());
+ }
+ else SW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWHomokineticPair::Share (const Handle(StepKinematics_HomokineticPair)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+
+ // Inherited fields of UniversalPair
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_HomokineticPair)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_HomokineticPair)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_HomokineticPair)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWHomokineticPair_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWKinematicJoint.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_KinematicJoint)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,3,ach,"kinematic_joint") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of Edge
+
+ Handle(StepShape_Vertex) aEdge_EdgeStart;
+ data->ReadEntity (num, 2, "edge.edge_start", ach, STANDARD_TYPE(StepShape_Vertex), aEdge_EdgeStart);
+
+ Handle(StepShape_Vertex) aEdge_EdgeEnd;
+ data->ReadEntity (num, 3, "edge.edge_end", ach, STANDARD_TYPE(StepShape_Vertex), aEdge_EdgeEnd);
+
+ // Initialize entity
+ ent->Init(aRepresentationItem_Name,
+ aEdge_EdgeStart,
+ aEdge_EdgeEnd);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWKinematicJoint::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_KinematicJoint)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Own fields of Edge
+
+ SW.Send (ent->EdgeStart());
+
+ SW.Send (ent->EdgeEnd());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWKinematicJoint::Share (const Handle(StepKinematics_KinematicJoint)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of Edge
+
+ iter.AddItem (ent->StepShape_Edge::EdgeStart());
+
+ iter.AddItem (ent->StepShape_Edge::EdgeEnd());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_KinematicJoint)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_KinematicJoint)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_KinematicJoint)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWKinematicJoint_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWKinematicLink.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_KinematicLink)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,1,ach,"kinematic_link") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Initialize entity
+ ent->Init(aRepresentationItem_Name);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWKinematicLink::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_KinematicLink)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWKinematicLink::Share (const Handle(StepKinematics_KinematicLink)& /*ent*/,
+ Interface_EntityIterator& /*iter*/) const
+{
+
+ // Inherited fields of RepresentationItem
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_KinematicLink)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_KinematicLink)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_KinematicLink)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWKinematicLink_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWKinematicLinkRepresentationAssociation.hxx>
+#include <StepKinematics_KinematicLinkRepresentationAssociation.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_RepresentationOrRepresentationReference.hxx>
+#include <StepRepr_Representation.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWKinematicLinkRepresentationAssociation
+//purpose :
+//=======================================================================
+
+RWStepKinematics_RWKinematicLinkRepresentationAssociation::RWStepKinematics_RWKinematicLinkRepresentationAssociation() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWKinematicLinkRepresentationAssociation::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_KinematicLinkRepresentationAssociation)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,4,ach,"kinematic_link_representation_association") ) return;
+
+ // Inherited fields of RepresentationRelationship
+
+ Handle(TCollection_HAsciiString) aRepresentationRelationship_Name;
+ data->ReadString (num, 1, "representation_relationship.name", ach, aRepresentationRelationship_Name);
+
+ Handle(TCollection_HAsciiString) aRepresentationRelationship_Description;
+ Standard_Boolean hasRepresentationRelationship_Description = Standard_True;
+ if ( data->IsParamDefined (num,2) ) {
+ data->ReadString (num, 2, "representation_relationship.description", ach, aRepresentationRelationship_Description);
+ }
+ else {
+ hasRepresentationRelationship_Description = Standard_False;
+ aRepresentationRelationship_Description.Nullify();
+ }
+
+ StepRepr_RepresentationOrRepresentationReference aRepresentationRelationship_Rep1;
+ data->ReadEntity (num, 3, "representation_relationship.rep1", ach, aRepresentationRelationship_Rep1);
+
+ StepRepr_RepresentationOrRepresentationReference aRepresentationRelationship_Rep2;
+ data->ReadEntity (num, 4, "representation_relationship.rep2", ach, aRepresentationRelationship_Rep2);
+
+ // Process only one type (Representaion)
+ if (aRepresentationRelationship_Rep1.CaseNumber() != 1 ||
+ aRepresentationRelationship_Rep1.CaseNumber() != 1)
+ return;
+
+ // Initialize entity
+ ent->Init(aRepresentationRelationship_Name,
+ /*hasRepresentationRelationship_Description,*/
+ aRepresentationRelationship_Description,
+ aRepresentationRelationship_Rep1.Representation(),
+ aRepresentationRelationship_Rep2.Representation());
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWKinematicLinkRepresentationAssociation::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_KinematicLinkRepresentationAssociation)& ent) const
+{
+
+ // Own fields of RepresentationRelationship
+
+ SW.Send (ent->Name());
+
+ if ( ent->HasDescription() ) {
+ SW.Send (ent->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->Rep1());
+
+ SW.Send (ent->Rep2());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWKinematicLinkRepresentationAssociation::Share (const Handle(StepKinematics_KinematicLinkRepresentationAssociation)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationRelationship
+
+ iter.AddItem (ent->StepRepr_RepresentationRelationship::Rep1());
+
+ iter.AddItem (ent->StepRepr_RepresentationRelationship::Rep2());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_KinematicLinkRepresentationAssociation)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_KinematicLinkRepresentationAssociation)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_KinematicLinkRepresentationAssociation)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWKinematicLinkRepresentationAssociation_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWKinematicPropertyMechanismRepresentation.hxx>
+#include <StepKinematics_KinematicPropertyMechanismRepresentation.hxx>
+#include <StepRepr_RepresentedDefinition.hxx>
+#include <StepRepr_Representation.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWKinematicPropertyMechanismRepresentation
+//purpose :
+//=======================================================================
+
+RWStepKinematics_RWKinematicPropertyMechanismRepresentation::RWStepKinematics_RWKinematicPropertyMechanismRepresentation() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWKinematicPropertyMechanismRepresentation::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_KinematicPropertyMechanismRepresentation)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,2,ach,"kinematic_property_mechanism_representation") ) return;
+
+ // Inherited fields of PropertyDefinitionRepresentation
+
+ StepRepr_RepresentedDefinition aPropertyDefinitionRepresentation_Definition;
+ data->ReadEntity (num, 1, "property_definition_representation.definition", ach, aPropertyDefinitionRepresentation_Definition);
+
+ Handle(StepRepr_Representation) aPropertyDefinitionRepresentation_UsedRepresentation;
+ data->ReadEntity (num, 2, "property_definition_representation.used_representation", ach, STANDARD_TYPE(StepRepr_Representation), aPropertyDefinitionRepresentation_UsedRepresentation);
+
+ // Initialize entity
+ ent->Init(aPropertyDefinitionRepresentation_Definition,
+ aPropertyDefinitionRepresentation_UsedRepresentation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWKinematicPropertyMechanismRepresentation::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_KinematicPropertyMechanismRepresentation)& ent) const
+{
+
+ // Own fields of PropertyDefinitionRepresentation
+
+ SW.Send (ent->Definition().Value());
+
+ SW.Send (ent->UsedRepresentation());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWKinematicPropertyMechanismRepresentation::Share (const Handle(StepKinematics_KinematicPropertyMechanismRepresentation)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of PropertyDefinitionRepresentation
+
+ iter.AddItem (ent->StepRepr_PropertyDefinitionRepresentation::Definition().Value());
+
+ iter.AddItem (ent->StepRepr_PropertyDefinitionRepresentation::UsedRepresentation());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_KinematicPropertyMechanismRepresentation)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_KinematicPropertyMechanismRepresentation)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_KinematicPropertyMechanismRepresentation)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWKinematicPropertyMechanismRepresentation_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWKinematicTopologyStructure.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_KinematicTopologyStructure)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,3,ach,"kinematic_topology_structure") ) return;
+
+ // Inherited fields of Representation
+
+ Handle(TCollection_HAsciiString) aRepresentation_Name;
+ data->ReadString (num, 1, "representation.name", ach, aRepresentation_Name);
+
+ Handle(StepRepr_HArray1OfRepresentationItem) aRepresentation_Items;
+ Standard_Integer sub2 = 0;
+ if ( data->ReadSubList (num, 2, "representation.items", ach, sub2) ) {
+ Standard_Integer nb0 = data->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;
+ data->ReadEntity (num2, i0, "representation_item", ach, STANDARD_TYPE(StepRepr_RepresentationItem), anIt0);
+ aRepresentation_Items->SetValue(i0, anIt0);
+ }
+ }
+
+ Handle(StepRepr_RepresentationContext) aRepresentation_ContextOfItems;
+ data->ReadEntity (num, 3, "representation.context_of_items", ach, STANDARD_TYPE(StepRepr_RepresentationContext), aRepresentation_ContextOfItems);
+
+ // Initialize entity
+ ent->Init(aRepresentation_Name,
+ aRepresentation_Items,
+ aRepresentation_ContextOfItems);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWKinematicTopologyStructure::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_KinematicTopologyStructure)& ent) const
+{
+
+ // Own fields of Representation
+
+ SW.Send (ent->Name());
+
+ SW.OpenSub();
+ for (Standard_Integer i1=1; i1 <= ent->Items()->Length(); i1++ ) {
+ Handle(StepRepr_RepresentationItem) Var0 = ent->Items()->Value(i1);
+ SW.Send (Var0);
+ }
+ SW.CloseSub();
+
+ SW.Send (ent->ContextOfItems());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWKinematicTopologyStructure::Share (const Handle(StepKinematics_KinematicTopologyStructure)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of Representation
+
+ for (Standard_Integer i1=1; i1 <= ent->StepRepr_Representation::Items()->Length(); i1++ ) {
+ Handle(StepRepr_RepresentationItem) Var0 = ent->StepRepr_Representation::Items()->Value(i1);
+ iter.AddItem (Var0);
+ }
+
+ iter.AddItem (ent->StepRepr_Representation::ContextOfItems());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_KinematicTopologyStructure)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_KinematicTopologyStructure)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_KinematicTopologyStructure)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWKinematicTopologyStructure_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWLowOrderKinematicPair.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_LowOrderKinematicPair)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,12,ach,"low_order_kinematic_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Own fields of LowOrderKinematicPair
+
+ Standard_Boolean aTX;
+ data->ReadBoolean (num, 7, "t_x", ach, aTX);
+
+ Standard_Boolean aTY;
+ data->ReadBoolean (num, 8, "t_y", ach, aTY);
+
+ Standard_Boolean aTZ;
+ data->ReadBoolean (num, 9, "t_z", ach, aTZ);
+
+ Standard_Boolean aRX;
+ data->ReadBoolean (num, 10, "r_x", ach, aRX);
+
+ Standard_Boolean aRY;
+ data->ReadBoolean (num, 11, "r_y", ach, aRY);
+
+ Standard_Boolean aRZ;
+ data->ReadBoolean (num, 12, "r_z", ach, aRZ);
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_LowOrderKinematicPair)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ SW.SendBoolean (ent->TX());
+
+ SW.SendBoolean (ent->TY());
+
+ SW.SendBoolean (ent->TZ());
+
+ SW.SendBoolean (ent->RX());
+
+ SW.SendBoolean (ent->RY());
+
+ SW.SendBoolean (ent->RZ());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWLowOrderKinematicPair::Share (const Handle(StepKinematics_LowOrderKinematicPair)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Own fields of LowOrderKinematicPair
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_LowOrderKinematicPair)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_LowOrderKinematicPair)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_LowOrderKinematicPair)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWLowOrderKinematicPair_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWLowOrderKinematicPairValue.hxx>
+#include <StepKinematics_LowOrderKinematicPairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWLowOrderKinematicPairValue
+//purpose :
+//=======================================================================
+
+RWStepKinematics_RWLowOrderKinematicPairValue::RWStepKinematics_RWLowOrderKinematicPairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWLowOrderKinematicPairValue::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_LowOrderKinematicPairValue)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,2,ach,"low_order_kinematic_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ data->ReadEntity (num, 2, "pair_value.applies_to_pair", ach, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Initialize entity
+ ent->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWLowOrderKinematicPairValue::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_LowOrderKinematicPairValue)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Own fields of PairValue
+
+ SW.Send (ent->AppliesToPair());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWLowOrderKinematicPairValue::Share (const Handle(StepKinematics_LowOrderKinematicPairValue)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (ent->StepKinematics_PairValue::AppliesToPair());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_LowOrderKinematicPairValue)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_LowOrderKinematicPairValue)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_LowOrderKinematicPairValue)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWLowOrderKinematicPairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWLowOrderKinematicPairWithRange.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_LowOrderKinematicPairWithRange)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,24,ach,"low_order_kinematic_pair_with_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ data->ReadBoolean (num, 7, "low_order_kinematic_pair.t_x", ach, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ data->ReadBoolean (num, 8, "low_order_kinematic_pair.t_y", ach, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ data->ReadBoolean (num, 9, "low_order_kinematic_pair.t_z", ach, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ data->ReadBoolean (num, 10, "low_order_kinematic_pair.r_x", ach, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ data->ReadBoolean (num, 11, "low_order_kinematic_pair.r_y", ach, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ data->ReadBoolean (num, 12, "low_order_kinematic_pair.r_z", ach, aLowOrderKinematicPair_RZ);
+
+ // Own fields of LowOrderKinematicPairWithRange
+
+ Standard_Real aLowerLimitActualRotationX;
+ Standard_Boolean hasLowerLimitActualRotationX = Standard_True;
+ if ( data->IsParamDefined (num,13) ) {
+ data->ReadReal (num, 13, "lower_limit_actual_rotation_x", ach, aLowerLimitActualRotationX);
+ }
+ else {
+ hasLowerLimitActualRotationX = Standard_False;
+ aLowerLimitActualRotationX = 0;
+ }
+
+ Standard_Real aUpperLimitActualRotationX;
+ Standard_Boolean hasUpperLimitActualRotationX = Standard_True;
+ if ( data->IsParamDefined (num,14) ) {
+ data->ReadReal (num, 14, "upper_limit_actual_rotation_x", ach, aUpperLimitActualRotationX);
+ }
+ else {
+ hasUpperLimitActualRotationX = Standard_False;
+ aUpperLimitActualRotationX = 0;
+ }
+
+ Standard_Real aLowerLimitActualRotationY;
+ Standard_Boolean hasLowerLimitActualRotationY = Standard_True;
+ if ( data->IsParamDefined (num,15) ) {
+ data->ReadReal (num, 15, "lower_limit_actual_rotation_y", ach, aLowerLimitActualRotationY);
+ }
+ else {
+ hasLowerLimitActualRotationY = Standard_False;
+ aLowerLimitActualRotationY = 0;
+ }
+
+ Standard_Real aUpperLimitActualRotationY;
+ Standard_Boolean hasUpperLimitActualRotationY = Standard_True;
+ if ( data->IsParamDefined (num,16) ) {
+ data->ReadReal (num, 16, "upper_limit_actual_rotation_y", ach, aUpperLimitActualRotationY);
+ }
+ else {
+ hasUpperLimitActualRotationY = Standard_False;
+ aUpperLimitActualRotationY = 0;
+ }
+
+ Standard_Real aLowerLimitActualRotationZ;
+ Standard_Boolean hasLowerLimitActualRotationZ = Standard_True;
+ if ( data->IsParamDefined (num,17) ) {
+ data->ReadReal (num, 17, "lower_limit_actual_rotation_z", ach, aLowerLimitActualRotationZ);
+ }
+ else {
+ hasLowerLimitActualRotationZ = Standard_False;
+ aLowerLimitActualRotationZ = 0;
+ }
+
+ Standard_Real aUpperLimitActualRotationZ;
+ Standard_Boolean hasUpperLimitActualRotationZ = Standard_True;
+ if ( data->IsParamDefined (num,18) ) {
+ data->ReadReal (num, 18, "upper_limit_actual_rotation_z", ach, aUpperLimitActualRotationZ);
+ }
+ else {
+ hasUpperLimitActualRotationZ = Standard_False;
+ aUpperLimitActualRotationZ = 0;
+ }
+
+ Standard_Real aLowerLimitActualTranslationX;
+ Standard_Boolean hasLowerLimitActualTranslationX = Standard_True;
+ if ( data->IsParamDefined (num,19) ) {
+ data->ReadReal (num, 19, "lower_limit_actual_translation_x", ach, aLowerLimitActualTranslationX);
+ }
+ else {
+ hasLowerLimitActualTranslationX = Standard_False;
+ aLowerLimitActualTranslationX = 0;
+ }
+
+ Standard_Real aUpperLimitActualTranslationX;
+ Standard_Boolean hasUpperLimitActualTranslationX = Standard_True;
+ if ( data->IsParamDefined (num,20) ) {
+ data->ReadReal (num, 20, "upper_limit_actual_translation_x", ach, aUpperLimitActualTranslationX);
+ }
+ else {
+ hasUpperLimitActualTranslationX = Standard_False;
+ aUpperLimitActualTranslationX = 0;
+ }
+
+ Standard_Real aLowerLimitActualTranslationY;
+ Standard_Boolean hasLowerLimitActualTranslationY = Standard_True;
+ if ( data->IsParamDefined (num,21) ) {
+ data->ReadReal (num, 21, "lower_limit_actual_translation_y", ach, aLowerLimitActualTranslationY);
+ }
+ else {
+ hasLowerLimitActualTranslationY = Standard_False;
+ aLowerLimitActualTranslationY = 0;
+ }
+
+ Standard_Real aUpperLimitActualTranslationY;
+ Standard_Boolean hasUpperLimitActualTranslationY = Standard_True;
+ if ( data->IsParamDefined (num,22) ) {
+ data->ReadReal (num, 22, "upper_limit_actual_translation_y", ach, aUpperLimitActualTranslationY);
+ }
+ else {
+ hasUpperLimitActualTranslationY = Standard_False;
+ aUpperLimitActualTranslationY = 0;
+ }
+
+ Standard_Real aLowerLimitActualTranslationZ;
+ Standard_Boolean hasLowerLimitActualTranslationZ = Standard_True;
+ if ( data->IsParamDefined (num,23) ) {
+ data->ReadReal (num, 23, "lower_limit_actual_translation_z", ach, aLowerLimitActualTranslationZ);
+ }
+ else {
+ hasLowerLimitActualTranslationZ = Standard_False;
+ aLowerLimitActualTranslationZ = 0;
+ }
+
+ Standard_Real aUpperLimitActualTranslationZ;
+ Standard_Boolean hasUpperLimitActualTranslationZ = Standard_True;
+ if ( data->IsParamDefined (num,24) ) {
+ data->ReadReal (num, 24, "upper_limit_actual_translation_z", ach, aUpperLimitActualTranslationZ);
+ }
+ else {
+ hasUpperLimitActualTranslationZ = Standard_False;
+ aUpperLimitActualTranslationZ = 0;
+ }
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_LowOrderKinematicPairWithRange)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ SW.SendBoolean (ent->TX());
+
+ SW.SendBoolean (ent->TY());
+
+ SW.SendBoolean (ent->TZ());
+
+ SW.SendBoolean (ent->RX());
+
+ SW.SendBoolean (ent->RY());
+
+ SW.SendBoolean (ent->RZ());
+
+ // Own fields of LowOrderKinematicPairWithRange
+
+ if ( ent->HasLowerLimitActualRotationX() ) {
+ SW.Send (ent->LowerLimitActualRotationX());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitActualRotationX() ) {
+ SW.Send (ent->UpperLimitActualRotationX());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasLowerLimitActualRotationY() ) {
+ SW.Send (ent->LowerLimitActualRotationY());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitActualRotationY() ) {
+ SW.Send (ent->UpperLimitActualRotationY());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasLowerLimitActualRotationZ() ) {
+ SW.Send (ent->LowerLimitActualRotationZ());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitActualRotationZ() ) {
+ SW.Send (ent->UpperLimitActualRotationZ());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasLowerLimitActualTranslationX() ) {
+ SW.Send (ent->LowerLimitActualTranslationX());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitActualTranslationX() ) {
+ SW.Send (ent->UpperLimitActualTranslationX());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasLowerLimitActualTranslationY() ) {
+ SW.Send (ent->LowerLimitActualTranslationY());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitActualTranslationY() ) {
+ SW.Send (ent->UpperLimitActualTranslationY());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasLowerLimitActualTranslationZ() ) {
+ SW.Send (ent->LowerLimitActualTranslationZ());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitActualTranslationZ() ) {
+ SW.Send (ent->UpperLimitActualTranslationZ());
+ }
+ else SW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWLowOrderKinematicPairWithRange::Share (const Handle(StepKinematics_LowOrderKinematicPairWithRange)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+
+ // Own fields of LowOrderKinematicPairWithRange
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_LowOrderKinematicPairWithRange)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_LowOrderKinematicPairWithRange)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_LowOrderKinematicPairWithRange)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWLowOrderKinematicPairWithRange_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWMechanismRepresentation.hxx>
+#include <StepKinematics_MechanismRepresentation.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_RepresentationContext.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWMechanismRepresentation
+//purpose :
+//=======================================================================
+
+RWStepKinematics_RWMechanismRepresentation::RWStepKinematics_RWMechanismRepresentation() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWMechanismRepresentation::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_MechanismRepresentation)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,3,ach,"mechanism_representation") ) return;
+
+ // Inherited fields of Representation
+
+ Handle(TCollection_HAsciiString) aRepresentation_Name;
+ data->ReadString (num, 1, "representation.name", ach, aRepresentation_Name);
+
+ Handle(StepRepr_HArray1OfRepresentationItem) aRepresentation_Items;
+ Standard_Integer sub2 = 0;
+ if ( data->ReadSubList (num, 2, "representation.items", ach, sub2) ) {
+ Standard_Integer nb0 = data->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;
+ data->ReadEntity (num2, i0, "representation_item", ach, STANDARD_TYPE(StepRepr_RepresentationItem), anIt0);
+ aRepresentation_Items->SetValue(i0, anIt0);
+ }
+ }
+
+ Handle(StepRepr_RepresentationContext) aRepresentation_ContextOfItems;
+ data->ReadEntity (num, 3, "representation.context_of_items", ach, STANDARD_TYPE(StepRepr_RepresentationContext), aRepresentation_ContextOfItems);
+
+ // Initialize entity
+ ent->Init(aRepresentation_Name,
+ aRepresentation_Items,
+ aRepresentation_ContextOfItems);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWMechanismRepresentation::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_MechanismRepresentation)& ent) const
+{
+
+ // Own fields of Representation
+
+ SW.Send (ent->Name());
+
+ SW.OpenSub();
+ for (Standard_Integer i1=1; i1 <= ent->Items()->Length(); i1++ ) {
+ Handle(StepRepr_RepresentationItem) Var0 = ent->Items()->Value(i1);
+ SW.Send (Var0);
+ }
+ SW.CloseSub();
+
+ SW.Send (ent->ContextOfItems());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWMechanismRepresentation::Share (const Handle(StepKinematics_MechanismRepresentation)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of Representation
+
+ for (Standard_Integer i1=1; i1 <= ent->StepRepr_Representation::Items()->Length(); i1++ ) {
+ Handle(StepRepr_RepresentationItem) Var0 = ent->StepRepr_Representation::Items()->Value(i1);
+ iter.AddItem (Var0);
+ }
+
+ iter.AddItem (ent->StepRepr_Representation::ContextOfItems());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_MechanismRepresentation)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_MechanismRepresentation)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_MechanismRepresentation)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWMechanismRepresentation_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWOrientedJoint.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_OrientedJoint)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,5,ach,"oriented_joint") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of Edge
+
+ Handle(StepShape_Vertex) aEdge_EdgeStart;
+ data->ReadEntity (num, 2, "edge.edge_start", ach, STANDARD_TYPE(StepShape_Vertex), aEdge_EdgeStart);
+
+ Handle(StepShape_Vertex) aEdge_EdgeEnd;
+ data->ReadEntity (num, 3, "edge.edge_end", ach, STANDARD_TYPE(StepShape_Vertex), aEdge_EdgeEnd);
+
+ // Inherited fields of OrientedEdge
+
+ Handle(StepShape_Edge) aOrientedEdge_EdgeElement;
+ data->ReadEntity (num, 4, "oriented_edge.edge_element", ach, STANDARD_TYPE(StepShape_Edge), aOrientedEdge_EdgeElement);
+
+ Standard_Boolean aOrientedEdge_Orientation;
+ data->ReadBoolean (num, 5, "oriented_edge.orientation", ach, aOrientedEdge_Orientation);
+
+ // Initialize entity
+ ent->Init(aRepresentationItem_Name,
+ aOrientedEdge_EdgeElement,
+ aOrientedEdge_Orientation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWOrientedJoint::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_OrientedJoint)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Own fields of Edge
+
+ SW.Send (ent->EdgeStart());
+
+ SW.Send (ent->EdgeEnd());
+
+ // Own fields of OrientedEdge
+
+ SW.Send (ent->EdgeElement());
+
+ SW.SendBoolean (ent->Orientation());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWOrientedJoint::Share (const Handle(StepKinematics_OrientedJoint)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of Edge
+
+ iter.AddItem (ent->StepShape_Edge::EdgeStart());
+
+ iter.AddItem (ent->StepShape_Edge::EdgeEnd());
+
+ // Inherited fields of OrientedEdge
+
+ iter.AddItem (ent->StepShape_OrientedEdge::EdgeElement());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_OrientedJoint)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_OrientedJoint)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_OrientedJoint)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWOrientedJoint_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWPlanarCurvePair.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_PlanarCurvePair)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,9,ach,"planar_curve_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Own fields of PlanarCurvePair
+
+ Handle(StepGeom_Curve) aCurve1;
+ data->ReadEntity (num, 7, "curve1", ach, STANDARD_TYPE(StepGeom_Curve), aCurve1);
+
+ Handle(StepGeom_Curve) aCurve2;
+ data->ReadEntity (num, 8, "curve2", ach, STANDARD_TYPE(StepGeom_Curve), aCurve2);
+
+ Standard_Boolean aOrientation;
+ data->ReadBoolean (num, 9, "orientation", ach, aOrientation);
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_PlanarCurvePair)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of PlanarCurvePair
+
+ SW.Send (ent->Curve1());
+
+ SW.Send (ent->Curve2());
+
+ SW.SendBoolean (ent->Orientation());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWPlanarCurvePair::Share (const Handle(StepKinematics_PlanarCurvePair)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Own fields of PlanarCurvePair
+
+ iter.AddItem (ent->Curve1());
+
+ iter.AddItem (ent->Curve2());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_PlanarCurvePair)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_PlanarCurvePair)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PlanarCurvePair)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPlanarCurvePair_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWPlanarCurvePairRange.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_PlanarCurvePairRange)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,11,ach,"planar_curve_pair_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of PlanarCurvePair
+
+ Handle(StepGeom_Curve) aPlanarCurvePair_Curve1;
+ data->ReadEntity (num, 7, "planar_curve_pair.curve1", ach, STANDARD_TYPE(StepGeom_Curve), aPlanarCurvePair_Curve1);
+
+ Handle(StepGeom_Curve) aPlanarCurvePair_Curve2;
+ data->ReadEntity (num, 8, "planar_curve_pair.curve2", ach, STANDARD_TYPE(StepGeom_Curve), aPlanarCurvePair_Curve2);
+
+ Standard_Boolean aPlanarCurvePair_Orientation;
+ data->ReadBoolean (num, 9, "planar_curve_pair.orientation", ach, aPlanarCurvePair_Orientation);
+
+ // Own fields of PlanarCurvePairRange
+
+ Handle(StepGeom_TrimmedCurve) aRangeOnCurve1;
+ data->ReadEntity (num, 10, "range_on_curve1", ach, STANDARD_TYPE(StepGeom_TrimmedCurve), aRangeOnCurve1);
+
+ Handle(StepGeom_TrimmedCurve) aRangeOnCurve2;
+ data->ReadEntity (num, 11, "range_on_curve2", ach, STANDARD_TYPE(StepGeom_TrimmedCurve), aRangeOnCurve2);
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_PlanarCurvePairRange)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of PlanarCurvePair
+
+ SW.Send (ent->Curve1());
+
+ SW.Send (ent->Curve2());
+
+ SW.SendBoolean (ent->Orientation());
+
+ // Own fields of PlanarCurvePairRange
+
+ SW.Send (ent->RangeOnCurve1());
+
+ SW.Send (ent->RangeOnCurve2());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWPlanarCurvePairRange::Share (const Handle(StepKinematics_PlanarCurvePairRange)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of PlanarCurvePair
+
+ iter.AddItem (ent->StepKinematics_PlanarCurvePair::Curve1());
+
+ iter.AddItem (ent->StepKinematics_PlanarCurvePair::Curve2());
+
+ // Own fields of PlanarCurvePairRange
+
+ iter.AddItem (ent->RangeOnCurve1());
+
+ iter.AddItem (ent->RangeOnCurve2());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_PlanarCurvePairRange)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_PlanarCurvePairRange)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PlanarCurvePairRange)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPlanarCurvePairRange_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWPlanarPair.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_PlanarPair)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,12,ach,"planar_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ data->ReadBoolean (num, 7, "low_order_kinematic_pair.t_x", ach, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ data->ReadBoolean (num, 8, "low_order_kinematic_pair.t_y", ach, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ data->ReadBoolean (num, 9, "low_order_kinematic_pair.t_z", ach, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ data->ReadBoolean (num, 10, "low_order_kinematic_pair.r_x", ach, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ data->ReadBoolean (num, 11, "low_order_kinematic_pair.r_y", ach, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ data->ReadBoolean (num, 12, "low_order_kinematic_pair.r_z", ach, aLowOrderKinematicPair_RZ);
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_PlanarPair)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ SW.SendBoolean (ent->TX());
+
+ SW.SendBoolean (ent->TY());
+
+ SW.SendBoolean (ent->TZ());
+
+ SW.SendBoolean (ent->RX());
+
+ SW.SendBoolean (ent->RY());
+
+ SW.SendBoolean (ent->RZ());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWPlanarPair::Share (const Handle(StepKinematics_PlanarPair)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_PlanarPair)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_PlanarPair)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PlanarPair)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPlanarPair_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWPlanarPairValue.hxx>
+#include <StepKinematics_PlanarPairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPlanarPairValue
+//purpose :
+//=======================================================================
+
+RWStepKinematics_RWPlanarPairValue::RWStepKinematics_RWPlanarPairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWPlanarPairValue::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_PlanarPairValue)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,2,ach,"planar_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ data->ReadEntity (num, 2, "pair_value.applies_to_pair", ach, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Initialize entity
+ ent->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWPlanarPairValue::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_PlanarPairValue)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Own fields of PairValue
+
+ SW.Send (ent->AppliesToPair());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWPlanarPairValue::Share (const Handle(StepKinematics_PlanarPairValue)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (ent->StepKinematics_PairValue::AppliesToPair());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_PlanarPairValue)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_PlanarPairValue)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PlanarPairValue)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPlanarPairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWPlanarPairWithRange.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_PlanarPairWithRange)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,18,ach,"planar_pair_with_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ data->ReadBoolean (num, 7, "low_order_kinematic_pair.t_x", ach, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ data->ReadBoolean (num, 8, "low_order_kinematic_pair.t_y", ach, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ data->ReadBoolean (num, 9, "low_order_kinematic_pair.t_z", ach, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ data->ReadBoolean (num, 10, "low_order_kinematic_pair.r_x", ach, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ data->ReadBoolean (num, 11, "low_order_kinematic_pair.r_y", ach, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ data->ReadBoolean (num, 12, "low_order_kinematic_pair.r_z", ach, aLowOrderKinematicPair_RZ);
+
+ // Own fields of PlanarPairWithRange
+
+ Standard_Real aLowerLimitActualRotation;
+ Standard_Boolean hasLowerLimitActualRotation = Standard_True;
+ if ( data->IsParamDefined (num,13) ) {
+ data->ReadReal (num, 13, "lower_limit_actual_rotation", ach, aLowerLimitActualRotation);
+ }
+ else {
+ hasLowerLimitActualRotation = Standard_False;
+ aLowerLimitActualRotation = 0;
+ }
+
+ Standard_Real aUpperLimitActualRotation;
+ Standard_Boolean hasUpperLimitActualRotation = Standard_True;
+ if ( data->IsParamDefined (num,14) ) {
+ data->ReadReal (num, 14, "upper_limit_actual_rotation", ach, aUpperLimitActualRotation);
+ }
+ else {
+ hasUpperLimitActualRotation = Standard_False;
+ aUpperLimitActualRotation = 0;
+ }
+
+ Standard_Real aLowerLimitActualTranslationX;
+ Standard_Boolean hasLowerLimitActualTranslationX = Standard_True;
+ if ( data->IsParamDefined (num,15) ) {
+ data->ReadReal (num, 15, "lower_limit_actual_translation_x", ach, aLowerLimitActualTranslationX);
+ }
+ else {
+ hasLowerLimitActualTranslationX = Standard_False;
+ aLowerLimitActualTranslationX = 0;
+ }
+
+ Standard_Real aUpperLimitActualTranslationX;
+ Standard_Boolean hasUpperLimitActualTranslationX = Standard_True;
+ if ( data->IsParamDefined (num,16) ) {
+ data->ReadReal (num, 16, "upper_limit_actual_translation_x", ach, aUpperLimitActualTranslationX);
+ }
+ else {
+ hasUpperLimitActualTranslationX = Standard_False;
+ aUpperLimitActualTranslationX = 0;
+ }
+
+ Standard_Real aLowerLimitActualTranslationY;
+ Standard_Boolean hasLowerLimitActualTranslationY = Standard_True;
+ if ( data->IsParamDefined (num,17) ) {
+ data->ReadReal (num, 17, "lower_limit_actual_translation_y", ach, aLowerLimitActualTranslationY);
+ }
+ else {
+ hasLowerLimitActualTranslationY = Standard_False;
+ aLowerLimitActualTranslationY = 0;
+ }
+
+ Standard_Real aUpperLimitActualTranslationY;
+ Standard_Boolean hasUpperLimitActualTranslationY = Standard_True;
+ if ( data->IsParamDefined (num,18) ) {
+ data->ReadReal (num, 18, "upper_limit_actual_translation_y", ach, aUpperLimitActualTranslationY);
+ }
+ else {
+ hasUpperLimitActualTranslationY = Standard_False;
+ aUpperLimitActualTranslationY = 0;
+ }
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_PlanarPairWithRange)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ SW.SendBoolean (ent->TX());
+
+ SW.SendBoolean (ent->TY());
+
+ SW.SendBoolean (ent->TZ());
+
+ SW.SendBoolean (ent->RX());
+
+ SW.SendBoolean (ent->RY());
+
+ SW.SendBoolean (ent->RZ());
+
+ // Own fields of PlanarPairWithRange
+
+ if ( ent->HasLowerLimitActualRotation() ) {
+ SW.Send (ent->LowerLimitActualRotation());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitActualRotation() ) {
+ SW.Send (ent->UpperLimitActualRotation());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasLowerLimitActualTranslationX() ) {
+ SW.Send (ent->LowerLimitActualTranslationX());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitActualTranslationX() ) {
+ SW.Send (ent->UpperLimitActualTranslationX());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasLowerLimitActualTranslationY() ) {
+ SW.Send (ent->LowerLimitActualTranslationY());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitActualTranslationY() ) {
+ SW.Send (ent->UpperLimitActualTranslationY());
+ }
+ else SW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWPlanarPairWithRange::Share (const Handle(StepKinematics_PlanarPairWithRange)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+
+ // Own fields of PlanarPairWithRange
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_PlanarPairWithRange)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_PlanarPairWithRange)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PlanarPairWithRange)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPlanarPairWithRange_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWPointOnPlanarCurvePair.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_PointOnPlanarCurvePair)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,8,ach,"point_on_planar_curve_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Own fields of PointOnPlanarCurvePair
+
+ Handle(StepGeom_Curve) aPairCurve;
+ data->ReadEntity (num, 7, "pair_curve", ach, STANDARD_TYPE(StepGeom_Curve), aPairCurve);
+
+ Standard_Boolean aOrientation;
+ data->ReadBoolean (num, 8, "orientation", ach, aOrientation);
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_PointOnPlanarCurvePair)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of PointOnPlanarCurvePair
+
+ SW.Send (ent->PairCurve());
+
+ SW.SendBoolean (ent->Orientation());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWPointOnPlanarCurvePair::Share (const Handle(StepKinematics_PointOnPlanarCurvePair)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Own fields of PointOnPlanarCurvePair
+
+ iter.AddItem (ent->PairCurve());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_PointOnPlanarCurvePair)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_PointOnPlanarCurvePair)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PointOnPlanarCurvePair)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPointOnPlanarCurvePair_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWPointOnPlanarCurvePairValue.hxx>
+#include <StepKinematics_PointOnPlanarCurvePairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPointOnPlanarCurvePairValue
+//purpose :
+//=======================================================================
+
+RWStepKinematics_RWPointOnPlanarCurvePairValue::RWStepKinematics_RWPointOnPlanarCurvePairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWPointOnPlanarCurvePairValue::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_PointOnPlanarCurvePairValue)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,2,ach,"point_on_planar_curve_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ data->ReadEntity (num, 2, "pair_value.applies_to_pair", ach, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Initialize entity
+ ent->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWPointOnPlanarCurvePairValue::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_PointOnPlanarCurvePairValue)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Own fields of PairValue
+
+ SW.Send (ent->AppliesToPair());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWPointOnPlanarCurvePairValue::Share (const Handle(StepKinematics_PointOnPlanarCurvePairValue)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (ent->StepKinematics_PairValue::AppliesToPair());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_PointOnPlanarCurvePairValue)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_PointOnPlanarCurvePairValue)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PointOnPlanarCurvePairValue)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPointOnPlanarCurvePairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWPointOnPlanarCurvePairWithRange.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_PointOnPlanarCurvePairWithRange)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,15,ach,"point_on_planar_curve_pair_with_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of PointOnPlanarCurvePair
+
+ Handle(StepGeom_Curve) aPointOnPlanarCurvePair_PairCurve;
+ data->ReadEntity (num, 7, "point_on_planar_curve_pair.pair_curve", ach, STANDARD_TYPE(StepGeom_Curve), aPointOnPlanarCurvePair_PairCurve);
+
+ Standard_Boolean aPointOnPlanarCurvePair_Orientation;
+ data->ReadBoolean (num, 8, "point_on_planar_curve_pair.orientation", ach, aPointOnPlanarCurvePair_Orientation);
+
+ // Own fields of PointOnPlanarCurvePairWithRange
+
+ Handle(StepGeom_TrimmedCurve) aRangeOnPairCurve;
+ data->ReadEntity (num, 9, "range_on_pair_curve", ach, STANDARD_TYPE(StepGeom_TrimmedCurve), aRangeOnPairCurve);
+
+ Standard_Real aLowerLimitYaw;
+ Standard_Boolean hasLowerLimitYaw = Standard_True;
+ if ( data->IsParamDefined (num,10) ) {
+ data->ReadReal (num, 10, "lower_limit_yaw", ach, aLowerLimitYaw);
+ }
+ else {
+ hasLowerLimitYaw = Standard_False;
+ aLowerLimitYaw = 0;
+ }
+
+ Standard_Real aUpperLimitYaw;
+ Standard_Boolean hasUpperLimitYaw = Standard_True;
+ if ( data->IsParamDefined (num,11) ) {
+ data->ReadReal (num, 11, "upper_limit_yaw", ach, aUpperLimitYaw);
+ }
+ else {
+ hasUpperLimitYaw = Standard_False;
+ aUpperLimitYaw = 0;
+ }
+
+ Standard_Real aLowerLimitPitch;
+ Standard_Boolean hasLowerLimitPitch = Standard_True;
+ if ( data->IsParamDefined (num,12) ) {
+ data->ReadReal (num, 12, "lower_limit_pitch", ach, aLowerLimitPitch);
+ }
+ else {
+ hasLowerLimitPitch = Standard_False;
+ aLowerLimitPitch = 0;
+ }
+
+ Standard_Real aUpperLimitPitch;
+ Standard_Boolean hasUpperLimitPitch = Standard_True;
+ if ( data->IsParamDefined (num,13) ) {
+ data->ReadReal (num, 13, "upper_limit_pitch", ach, aUpperLimitPitch);
+ }
+ else {
+ hasUpperLimitPitch = Standard_False;
+ aUpperLimitPitch = 0;
+ }
+
+ Standard_Real aLowerLimitRoll;
+ Standard_Boolean hasLowerLimitRoll = Standard_True;
+ if ( data->IsParamDefined (num,14) ) {
+ data->ReadReal (num, 14, "lower_limit_roll", ach, aLowerLimitRoll);
+ }
+ else {
+ hasLowerLimitRoll = Standard_False;
+ aLowerLimitRoll = 0;
+ }
+
+ Standard_Real aUpperLimitRoll;
+ Standard_Boolean hasUpperLimitRoll = Standard_True;
+ if ( data->IsParamDefined (num,15) ) {
+ data->ReadReal (num, 15, "upper_limit_roll", ach, aUpperLimitRoll);
+ }
+ else {
+ hasUpperLimitRoll = Standard_False;
+ aUpperLimitRoll = 0;
+ }
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_PointOnPlanarCurvePairWithRange)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of PointOnPlanarCurvePair
+
+ SW.Send (ent->PairCurve());
+
+ SW.SendBoolean (ent->Orientation());
+
+ // Own fields of PointOnPlanarCurvePairWithRange
+
+ SW.Send (ent->RangeOnPairCurve());
+
+ if ( ent->HasLowerLimitYaw() ) {
+ SW.Send (ent->LowerLimitYaw());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitYaw() ) {
+ SW.Send (ent->UpperLimitYaw());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasLowerLimitPitch() ) {
+ SW.Send (ent->LowerLimitPitch());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitPitch() ) {
+ SW.Send (ent->UpperLimitPitch());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasLowerLimitRoll() ) {
+ SW.Send (ent->LowerLimitRoll());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitRoll() ) {
+ SW.Send (ent->UpperLimitRoll());
+ }
+ else SW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWPointOnPlanarCurvePairWithRange::Share (const Handle(StepKinematics_PointOnPlanarCurvePairWithRange)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of PointOnPlanarCurvePair
+
+ iter.AddItem (ent->StepKinematics_PointOnPlanarCurvePair::PairCurve());
+
+ // Own fields of PointOnPlanarCurvePairWithRange
+
+ iter.AddItem (ent->RangeOnPairCurve());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_PointOnPlanarCurvePairWithRange)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_PointOnPlanarCurvePairWithRange)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PointOnPlanarCurvePairWithRange)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPointOnPlanarCurvePairWithRange_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWPointOnSurfacePair.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_PointOnSurfacePair)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,7,ach,"point_on_surface_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Own fields of PointOnSurfacePair
+
+ Handle(StepGeom_Surface) aPairSurface;
+ data->ReadEntity (num, 7, "pair_surface", ach, STANDARD_TYPE(StepGeom_Surface), aPairSurface);
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_PointOnSurfacePair)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of PointOnSurfacePair
+
+ SW.Send (ent->PairSurface());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWPointOnSurfacePair::Share (const Handle(StepKinematics_PointOnSurfacePair)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Own fields of PointOnSurfacePair
+
+ iter.AddItem (ent->PairSurface());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_PointOnSurfacePair)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_PointOnSurfacePair)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PointOnSurfacePair)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPointOnSurfacePair_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWPointOnSurfacePairValue.hxx>
+#include <StepKinematics_PointOnSurfacePairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPointOnSurfacePairValue
+//purpose :
+//=======================================================================
+
+RWStepKinematics_RWPointOnSurfacePairValue::RWStepKinematics_RWPointOnSurfacePairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWPointOnSurfacePairValue::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_PointOnSurfacePairValue)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,2,ach,"point_on_surface_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ data->ReadEntity (num, 2, "pair_value.applies_to_pair", ach, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Initialize entity
+ ent->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWPointOnSurfacePairValue::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_PointOnSurfacePairValue)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Own fields of PairValue
+
+ SW.Send (ent->AppliesToPair());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWPointOnSurfacePairValue::Share (const Handle(StepKinematics_PointOnSurfacePairValue)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (ent->StepKinematics_PairValue::AppliesToPair());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_PointOnSurfacePairValue)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_PointOnSurfacePairValue)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PointOnSurfacePairValue)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPointOnSurfacePairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWPointOnSurfacePairWithRange.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_PointOnSurfacePairWithRange)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,14,ach,"point_on_surface_pair_with_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of PointOnSurfacePair
+
+ Handle(StepGeom_Surface) aPointOnSurfacePair_PairSurface;
+ data->ReadEntity (num, 7, "point_on_surface_pair.pair_surface", ach, STANDARD_TYPE(StepGeom_Surface), aPointOnSurfacePair_PairSurface);
+
+ // Own fields of PointOnSurfacePairWithRange
+
+ Handle(StepGeom_RectangularTrimmedSurface) aRangeOnPairSurface;
+ data->ReadEntity (num, 8, "range_on_pair_surface", ach, STANDARD_TYPE(StepGeom_RectangularTrimmedSurface), aRangeOnPairSurface);
+
+ Standard_Real aLowerLimitYaw;
+ Standard_Boolean hasLowerLimitYaw = Standard_True;
+ if ( data->IsParamDefined (num,9) ) {
+ data->ReadReal (num, 9, "lower_limit_yaw", ach, aLowerLimitYaw);
+ }
+ else {
+ hasLowerLimitYaw = Standard_False;
+ aLowerLimitYaw = 0;
+ }
+
+ Standard_Real aUpperLimitYaw;
+ Standard_Boolean hasUpperLimitYaw = Standard_True;
+ if ( data->IsParamDefined (num,10) ) {
+ data->ReadReal (num, 10, "upper_limit_yaw", ach, aUpperLimitYaw);
+ }
+ else {
+ hasUpperLimitYaw = Standard_False;
+ aUpperLimitYaw = 0;
+ }
+
+ Standard_Real aLowerLimitPitch;
+ Standard_Boolean hasLowerLimitPitch = Standard_True;
+ if ( data->IsParamDefined (num,11) ) {
+ data->ReadReal (num, 11, "lower_limit_pitch", ach, aLowerLimitPitch);
+ }
+ else {
+ hasLowerLimitPitch = Standard_False;
+ aLowerLimitPitch = 0;
+ }
+
+ Standard_Real aUpperLimitPitch;
+ Standard_Boolean hasUpperLimitPitch = Standard_True;
+ if ( data->IsParamDefined (num,12) ) {
+ data->ReadReal (num, 12, "upper_limit_pitch", ach, aUpperLimitPitch);
+ }
+ else {
+ hasUpperLimitPitch = Standard_False;
+ aUpperLimitPitch = 0;
+ }
+
+ Standard_Real aLowerLimitRoll;
+ Standard_Boolean hasLowerLimitRoll = Standard_True;
+ if ( data->IsParamDefined (num,13) ) {
+ data->ReadReal (num, 13, "lower_limit_roll", ach, aLowerLimitRoll);
+ }
+ else {
+ hasLowerLimitRoll = Standard_False;
+ aLowerLimitRoll = 0;
+ }
+
+ Standard_Real aUpperLimitRoll;
+ Standard_Boolean hasUpperLimitRoll = Standard_True;
+ if ( data->IsParamDefined (num,14) ) {
+ data->ReadReal (num, 14, "upper_limit_roll", ach, aUpperLimitRoll);
+ }
+ else {
+ hasUpperLimitRoll = Standard_False;
+ aUpperLimitRoll = 0;
+ }
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_PointOnSurfacePairWithRange)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of PointOnSurfacePair
+
+ SW.Send (ent->PairSurface());
+
+ // Own fields of PointOnSurfacePairWithRange
+
+ SW.Send (ent->RangeOnPairSurface());
+
+ if ( ent->HasLowerLimitYaw() ) {
+ SW.Send (ent->LowerLimitYaw());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitYaw() ) {
+ SW.Send (ent->UpperLimitYaw());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasLowerLimitPitch() ) {
+ SW.Send (ent->LowerLimitPitch());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitPitch() ) {
+ SW.Send (ent->UpperLimitPitch());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasLowerLimitRoll() ) {
+ SW.Send (ent->LowerLimitRoll());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitRoll() ) {
+ SW.Send (ent->UpperLimitRoll());
+ }
+ else SW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWPointOnSurfacePairWithRange::Share (const Handle(StepKinematics_PointOnSurfacePairWithRange)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of PointOnSurfacePair
+
+ iter.AddItem (ent->StepKinematics_PointOnSurfacePair::PairSurface());
+
+ // Own fields of PointOnSurfacePairWithRange
+
+ iter.AddItem (ent->RangeOnPairSurface());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_PointOnSurfacePairWithRange)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_PointOnSurfacePairWithRange)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PointOnSurfacePairWithRange)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPointOnSurfacePairWithRange_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWPrismaticPair.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_PrismaticPair)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,12,ach,"prismatic_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ data->ReadBoolean (num, 7, "low_order_kinematic_pair.t_x", ach, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ data->ReadBoolean (num, 8, "low_order_kinematic_pair.t_y", ach, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ data->ReadBoolean (num, 9, "low_order_kinematic_pair.t_z", ach, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ data->ReadBoolean (num, 10, "low_order_kinematic_pair.r_x", ach, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ data->ReadBoolean (num, 11, "low_order_kinematic_pair.r_y", ach, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ data->ReadBoolean (num, 12, "low_order_kinematic_pair.r_z", ach, aLowOrderKinematicPair_RZ);
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_PrismaticPair)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ SW.SendBoolean (ent->TX());
+
+ SW.SendBoolean (ent->TY());
+
+ SW.SendBoolean (ent->TZ());
+
+ SW.SendBoolean (ent->RX());
+
+ SW.SendBoolean (ent->RY());
+
+ SW.SendBoolean (ent->RZ());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWPrismaticPair::Share (const Handle(StepKinematics_PrismaticPair)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_PrismaticPair)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_PrismaticPair)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PrismaticPair)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPrismaticPair_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWPrismaticPairValue.hxx>
+#include <StepKinematics_PrismaticPairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPrismaticPairValue
+//purpose :
+//=======================================================================
+
+RWStepKinematics_RWPrismaticPairValue::RWStepKinematics_RWPrismaticPairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWPrismaticPairValue::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_PrismaticPairValue)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,2,ach,"prismatic_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ data->ReadEntity (num, 2, "pair_value.applies_to_pair", ach, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Initialize entity
+ ent->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWPrismaticPairValue::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_PrismaticPairValue)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Own fields of PairValue
+
+ SW.Send (ent->AppliesToPair());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWPrismaticPairValue::Share (const Handle(StepKinematics_PrismaticPairValue)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (ent->StepKinematics_PairValue::AppliesToPair());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_PrismaticPairValue)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_PrismaticPairValue)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PrismaticPairValue)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPrismaticPairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWPrismaticPairWithRange.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_PrismaticPairWithRange)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,14,ach,"prismatic_pair_with_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ data->ReadBoolean (num, 7, "low_order_kinematic_pair.t_x", ach, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ data->ReadBoolean (num, 8, "low_order_kinematic_pair.t_y", ach, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ data->ReadBoolean (num, 9, "low_order_kinematic_pair.t_z", ach, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ data->ReadBoolean (num, 10, "low_order_kinematic_pair.r_x", ach, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ data->ReadBoolean (num, 11, "low_order_kinematic_pair.r_y", ach, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ data->ReadBoolean (num, 12, "low_order_kinematic_pair.r_z", ach, aLowOrderKinematicPair_RZ);
+
+ // Own fields of PrismaticPairWithRange
+
+ Standard_Real aLowerLimitActualTranslation;
+ Standard_Boolean hasLowerLimitActualTranslation = Standard_True;
+ if ( data->IsParamDefined (num,13) ) {
+ data->ReadReal (num, 13, "lower_limit_actual_translation", ach, aLowerLimitActualTranslation);
+ }
+ else {
+ hasLowerLimitActualTranslation = Standard_False;
+ aLowerLimitActualTranslation = 0;
+ }
+
+ Standard_Real aUpperLimitActualTranslation;
+ Standard_Boolean hasUpperLimitActualTranslation = Standard_True;
+ if ( data->IsParamDefined (num,14) ) {
+ data->ReadReal (num, 14, "upper_limit_actual_translation", ach, aUpperLimitActualTranslation);
+ }
+ else {
+ hasUpperLimitActualTranslation = Standard_False;
+ aUpperLimitActualTranslation = 0;
+ }
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_PrismaticPairWithRange)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ SW.SendBoolean (ent->TX());
+
+ SW.SendBoolean (ent->TY());
+
+ SW.SendBoolean (ent->TZ());
+
+ SW.SendBoolean (ent->RX());
+
+ SW.SendBoolean (ent->RY());
+
+ SW.SendBoolean (ent->RZ());
+
+ // Own fields of PrismaticPairWithRange
+
+ if ( ent->HasLowerLimitActualTranslation() ) {
+ SW.Send (ent->LowerLimitActualTranslation());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitActualTranslation() ) {
+ SW.Send (ent->UpperLimitActualTranslation());
+ }
+ else SW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWPrismaticPairWithRange::Share (const Handle(StepKinematics_PrismaticPairWithRange)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+
+ // Own fields of PrismaticPairWithRange
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_PrismaticPairWithRange)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_PrismaticPairWithRange)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_PrismaticPairWithRange)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPrismaticPairWithRange_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWProductDefinitionKinematics.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_ProductDefinitionKinematics)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,3,ach,"product_definition_kinematics") ) return;
+
+ // Inherited fields of PropertyDefinition
+
+ Handle(TCollection_HAsciiString) aPropertyDefinition_Name;
+ data->ReadString (num, 1, "property_definition.name", ach, aPropertyDefinition_Name);
+
+ Handle(TCollection_HAsciiString) aPropertyDefinition_Description;
+ Standard_Boolean hasPropertyDefinition_Description = Standard_True;
+ if ( data->IsParamDefined (num,2) ) {
+ data->ReadString (num, 2, "property_definition.description", ach, aPropertyDefinition_Description);
+ }
+ else {
+ hasPropertyDefinition_Description = Standard_False;
+ aPropertyDefinition_Description.Nullify();
+ }
+
+ StepRepr_CharacterizedDefinition aPropertyDefinition_Definition;
+ data->ReadEntity (num, 3, "property_definition.definition", ach, aPropertyDefinition_Definition);
+
+ // Initialize entity
+ ent->Init(aPropertyDefinition_Name,
+ hasPropertyDefinition_Description,
+ aPropertyDefinition_Description,
+ aPropertyDefinition_Definition);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWProductDefinitionKinematics::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_ProductDefinitionKinematics)& ent) const
+{
+
+ // Own fields of PropertyDefinition
+
+ SW.Send (ent->Name());
+
+ if ( ent->HasDescription() ) {
+ SW.Send (ent->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->Definition().Value());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWProductDefinitionKinematics::Share (const Handle(StepKinematics_ProductDefinitionKinematics)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of PropertyDefinition
+
+ iter.AddItem (ent->StepRepr_PropertyDefinition::Definition().Value());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_ProductDefinitionKinematics)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_ProductDefinitionKinematics)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_ProductDefinitionKinematics)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWProductDefinitionKinematics_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWProductDefinitionRelationshipKinematics.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_ProductDefinitionRelationshipKinematics)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,3,ach,"product_definition_relationship_kinematics") ) return;
+
+ // Inherited fields of PropertyDefinition
+
+ Handle(TCollection_HAsciiString) aPropertyDefinition_Name;
+ data->ReadString (num, 1, "property_definition.name", ach, aPropertyDefinition_Name);
+
+ Handle(TCollection_HAsciiString) aPropertyDefinition_Description;
+ Standard_Boolean hasPropertyDefinition_Description = Standard_True;
+ if ( data->IsParamDefined (num,2) ) {
+ data->ReadString (num, 2, "property_definition.description", ach, aPropertyDefinition_Description);
+ }
+ else {
+ hasPropertyDefinition_Description = Standard_False;
+ aPropertyDefinition_Description.Nullify();
+ }
+
+ StepRepr_CharacterizedDefinition aPropertyDefinition_Definition;
+ data->ReadEntity (num, 3, "property_definition.definition", ach, aPropertyDefinition_Definition);
+
+ // Initialize entity
+ ent->Init(aPropertyDefinition_Name,
+ hasPropertyDefinition_Description,
+ aPropertyDefinition_Description,
+ aPropertyDefinition_Definition);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWProductDefinitionRelationshipKinematics::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_ProductDefinitionRelationshipKinematics)& ent) const
+{
+
+ // Own fields of PropertyDefinition
+
+ SW.Send (ent->Name());
+
+ if ( ent->HasDescription() ) {
+ SW.Send (ent->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->Definition().Value());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWProductDefinitionRelationshipKinematics::Share (const Handle(StepKinematics_ProductDefinitionRelationshipKinematics)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of PropertyDefinition
+
+ iter.AddItem (ent->StepRepr_PropertyDefinition::Definition().Value());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_ProductDefinitionRelationshipKinematics)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_ProductDefinitionRelationshipKinematics)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_ProductDefinitionRelationshipKinematics)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWProductDefinitionRelationshipKinematics_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWRackAndPinionPair.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_RackAndPinionPair)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,7,ach,"rack_and_pinion_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Own fields of RackAndPinionPair
+
+ Standard_Real aPinionRadius;
+ data->ReadReal (num, 7, "pinion_radius", ach, aPinionRadius);
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_RackAndPinionPair)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of RackAndPinionPair
+
+ SW.Send (ent->PinionRadius());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWRackAndPinionPair::Share (const Handle(StepKinematics_RackAndPinionPair)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Own fields of RackAndPinionPair
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_RackAndPinionPair)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_RackAndPinionPair)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_RackAndPinionPair)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWRackAndPinionPair_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWRackAndPinionPairValue.hxx>
+#include <StepKinematics_RackAndPinionPairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWRackAndPinionPairValue
+//purpose :
+//=======================================================================
+
+RWStepKinematics_RWRackAndPinionPairValue::RWStepKinematics_RWRackAndPinionPairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWRackAndPinionPairValue::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_RackAndPinionPairValue)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,2,ach,"rack_and_pinion_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ data->ReadEntity (num, 2, "pair_value.applies_to_pair", ach, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Initialize entity
+ ent->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWRackAndPinionPairValue::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_RackAndPinionPairValue)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Own fields of PairValue
+
+ SW.Send (ent->AppliesToPair());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWRackAndPinionPairValue::Share (const Handle(StepKinematics_RackAndPinionPairValue)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (ent->StepKinematics_PairValue::AppliesToPair());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_RackAndPinionPairValue)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_RackAndPinionPairValue)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_RackAndPinionPairValue)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWRackAndPinionPairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWRackAndPinionPairWithRange.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_RackAndPinionPairWithRange)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,9,ach,"rack_and_pinion_pair_with_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of RackAndPinionPair
+
+ Standard_Real aRackAndPinionPair_PinionRadius;
+ data->ReadReal (num, 7, "rack_and_pinion_pair.pinion_radius", ach, aRackAndPinionPair_PinionRadius);
+
+ // Own fields of RackAndPinionPairWithRange
+
+ Standard_Real aLowerLimitRackDisplacement;
+ Standard_Boolean hasLowerLimitRackDisplacement = Standard_True;
+ if ( data->IsParamDefined (num,8) ) {
+ data->ReadReal (num, 8, "lower_limit_rack_displacement", ach, aLowerLimitRackDisplacement);
+ }
+ else {
+ hasLowerLimitRackDisplacement = Standard_False;
+ aLowerLimitRackDisplacement = 0;
+ }
+
+ Standard_Real aUpperLimitRackDisplacement;
+ Standard_Boolean hasUpperLimitRackDisplacement = Standard_True;
+ if ( data->IsParamDefined (num,9) ) {
+ data->ReadReal (num, 9, "upper_limit_rack_displacement", ach, aUpperLimitRackDisplacement);
+ }
+ else {
+ hasUpperLimitRackDisplacement = Standard_False;
+ aUpperLimitRackDisplacement = 0;
+ }
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_RackAndPinionPairWithRange)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of RackAndPinionPair
+
+ SW.Send (ent->PinionRadius());
+
+ // Own fields of RackAndPinionPairWithRange
+
+ if ( ent->HasLowerLimitRackDisplacement() ) {
+ SW.Send (ent->LowerLimitRackDisplacement());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitRackDisplacement() ) {
+ SW.Send (ent->UpperLimitRackDisplacement());
+ }
+ else SW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWRackAndPinionPairWithRange::Share (const Handle(StepKinematics_RackAndPinionPairWithRange)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of RackAndPinionPair
+
+ // Own fields of RackAndPinionPairWithRange
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_RackAndPinionPairWithRange)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_RackAndPinionPairWithRange)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_RackAndPinionPairWithRange)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWRackAndPinionPairWithRange_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWRevolutePair.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_RevolutePair)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,12,ach,"revolute_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ data->ReadBoolean (num, 7, "low_order_kinematic_pair.t_x", ach, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ data->ReadBoolean (num, 8, "low_order_kinematic_pair.t_y", ach, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ data->ReadBoolean (num, 9, "low_order_kinematic_pair.t_z", ach, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ data->ReadBoolean (num, 10, "low_order_kinematic_pair.r_x", ach, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ data->ReadBoolean (num, 11, "low_order_kinematic_pair.r_y", ach, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ data->ReadBoolean (num, 12, "low_order_kinematic_pair.r_z", ach, aLowOrderKinematicPair_RZ);
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_RevolutePair)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ SW.SendBoolean (ent->TX());
+
+ SW.SendBoolean (ent->TY());
+
+ SW.SendBoolean (ent->TZ());
+
+ SW.SendBoolean (ent->RX());
+
+ SW.SendBoolean (ent->RY());
+
+ SW.SendBoolean (ent->RZ());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWRevolutePair::Share (const Handle(StepKinematics_RevolutePair)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_RevolutePair)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_RevolutePair)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_RevolutePair)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWRevolutePair_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWRevolutePairValue.hxx>
+#include <StepKinematics_RevolutePairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWRevolutePairValue
+//purpose :
+//=======================================================================
+
+RWStepKinematics_RWRevolutePairValue::RWStepKinematics_RWRevolutePairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWRevolutePairValue::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_RevolutePairValue)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,2,ach,"revolute_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ data->ReadEntity (num, 2, "pair_value.applies_to_pair", ach, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Initialize entity
+ ent->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWRevolutePairValue::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_RevolutePairValue)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Own fields of PairValue
+
+ SW.Send (ent->AppliesToPair());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWRevolutePairValue::Share (const Handle(StepKinematics_RevolutePairValue)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (ent->StepKinematics_PairValue::AppliesToPair());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_RevolutePairValue)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_RevolutePairValue)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_RevolutePairValue)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWRevolutePairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWRevolutePairWithRange.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_RevolutePairWithRange)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,14,ach,"revolute_pair_with_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ data->ReadBoolean (num, 7, "low_order_kinematic_pair.t_x", ach, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ data->ReadBoolean (num, 8, "low_order_kinematic_pair.t_y", ach, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ data->ReadBoolean (num, 9, "low_order_kinematic_pair.t_z", ach, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ data->ReadBoolean (num, 10, "low_order_kinematic_pair.r_x", ach, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ data->ReadBoolean (num, 11, "low_order_kinematic_pair.r_y", ach, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ data->ReadBoolean (num, 12, "low_order_kinematic_pair.r_z", ach, aLowOrderKinematicPair_RZ);
+
+ // Own fields of RevolutePairWithRange
+
+ Standard_Real aLowerLimitActualRotation;
+ Standard_Boolean hasLowerLimitActualRotation = Standard_True;
+ if ( data->IsParamDefined (num,13) ) {
+ data->ReadReal (num, 13, "lower_limit_actual_rotation", ach, aLowerLimitActualRotation);
+ }
+ else {
+ hasLowerLimitActualRotation = Standard_False;
+ aLowerLimitActualRotation = 0;
+ }
+
+ Standard_Real aUpperLimitActualRotation;
+ Standard_Boolean hasUpperLimitActualRotation = Standard_True;
+ if ( data->IsParamDefined (num,14) ) {
+ data->ReadReal (num, 14, "upper_limit_actual_rotation", ach, aUpperLimitActualRotation);
+ }
+ else {
+ hasUpperLimitActualRotation = Standard_False;
+ aUpperLimitActualRotation = 0;
+ }
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_RevolutePairWithRange)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ SW.SendBoolean (ent->TX());
+
+ SW.SendBoolean (ent->TY());
+
+ SW.SendBoolean (ent->TZ());
+
+ SW.SendBoolean (ent->RX());
+
+ SW.SendBoolean (ent->RY());
+
+ SW.SendBoolean (ent->RZ());
+
+ // Own fields of RevolutePairWithRange
+
+ if ( ent->HasLowerLimitActualRotation() ) {
+ SW.Send (ent->LowerLimitActualRotation());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitActualRotation() ) {
+ SW.Send (ent->UpperLimitActualRotation());
+ }
+ else SW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWRevolutePairWithRange::Share (const Handle(StepKinematics_RevolutePairWithRange)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+
+ // Own fields of RevolutePairWithRange
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_RevolutePairWithRange)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_RevolutePairWithRange)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_RevolutePairWithRange)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWRevolutePairWithRange_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWRollingCurvePair.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_RollingCurvePair)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,9,ach,"rolling_curve_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of PlanarCurvePair
+
+ Handle(StepGeom_Curve) aPlanarCurvePair_Curve1;
+ data->ReadEntity (num, 7, "planar_curve_pair.curve1", ach, STANDARD_TYPE(StepGeom_Curve), aPlanarCurvePair_Curve1);
+
+ Handle(StepGeom_Curve) aPlanarCurvePair_Curve2;
+ data->ReadEntity (num, 8, "planar_curve_pair.curve2", ach, STANDARD_TYPE(StepGeom_Curve), aPlanarCurvePair_Curve2);
+
+ Standard_Boolean aPlanarCurvePair_Orientation;
+ data->ReadBoolean (num, 9, "planar_curve_pair.orientation", ach, aPlanarCurvePair_Orientation);
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_RollingCurvePair)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of PlanarCurvePair
+
+ SW.Send (ent->Curve1());
+
+ SW.Send (ent->Curve2());
+
+ SW.SendBoolean (ent->Orientation());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWRollingCurvePair::Share (const Handle(StepKinematics_RollingCurvePair)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of PlanarCurvePair
+
+ iter.AddItem (ent->StepKinematics_PlanarCurvePair::Curve1());
+
+ iter.AddItem (ent->StepKinematics_PlanarCurvePair::Curve2());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_RollingCurvePair)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_RollingCurvePair)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_RollingCurvePair)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWRollingCurvePair_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWRollingCurvePairValue.hxx>
+#include <StepKinematics_RollingCurvePairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWRollingCurvePairValue
+//purpose :
+//=======================================================================
+
+RWStepKinematics_RWRollingCurvePairValue::RWStepKinematics_RWRollingCurvePairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWRollingCurvePairValue::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_RollingCurvePairValue)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,2,ach,"rolling_curve_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ data->ReadEntity (num, 2, "pair_value.applies_to_pair", ach, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Initialize entity
+ ent->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWRollingCurvePairValue::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_RollingCurvePairValue)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Own fields of PairValue
+
+ SW.Send (ent->AppliesToPair());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWRollingCurvePairValue::Share (const Handle(StepKinematics_RollingCurvePairValue)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (ent->StepKinematics_PairValue::AppliesToPair());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_RollingCurvePairValue)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_RollingCurvePairValue)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_RollingCurvePairValue)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWRollingCurvePairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWRollingSurfacePair.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_RollingSurfacePair)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,9,ach,"rolling_surface_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of SurfacePair
+
+ Handle(StepGeom_Surface) aSurfacePair_Surface1;
+ data->ReadEntity (num, 7, "surface_pair.surface1", ach, STANDARD_TYPE(StepGeom_Surface), aSurfacePair_Surface1);
+
+ Handle(StepGeom_Surface) aSurfacePair_Surface2;
+ data->ReadEntity (num, 8, "surface_pair.surface2", ach, STANDARD_TYPE(StepGeom_Surface), aSurfacePair_Surface2);
+
+ Standard_Boolean aSurfacePair_Orientation;
+ data->ReadBoolean (num, 9, "surface_pair.orientation", ach, aSurfacePair_Orientation);
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_RollingSurfacePair)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of SurfacePair
+
+ SW.Send (ent->Surface1());
+
+ SW.Send (ent->Surface2());
+
+ SW.SendBoolean (ent->Orientation());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWRollingSurfacePair::Share (const Handle(StepKinematics_RollingSurfacePair)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of SurfacePair
+
+ iter.AddItem (ent->StepKinematics_SurfacePair::Surface1());
+
+ iter.AddItem (ent->StepKinematics_SurfacePair::Surface2());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_RollingSurfacePair)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_RollingSurfacePair)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_RollingSurfacePair)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWRollingSurfacePair_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWRollingSurfacePairValue.hxx>
+#include <StepKinematics_RollingSurfacePairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWRollingSurfacePairValue
+//purpose :
+//=======================================================================
+
+RWStepKinematics_RWRollingSurfacePairValue::RWStepKinematics_RWRollingSurfacePairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWRollingSurfacePairValue::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_RollingSurfacePairValue)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,2,ach,"rolling_surface_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ data->ReadEntity (num, 2, "pair_value.applies_to_pair", ach, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Initialize entity
+ ent->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWRollingSurfacePairValue::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_RollingSurfacePairValue)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Own fields of PairValue
+
+ SW.Send (ent->AppliesToPair());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWRollingSurfacePairValue::Share (const Handle(StepKinematics_RollingSurfacePairValue)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (ent->StepKinematics_PairValue::AppliesToPair());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_RollingSurfacePairValue)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_RollingSurfacePairValue)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_RollingSurfacePairValue)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWRollingSurfacePairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWRotationAboutDirection.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_RotationAboutDirection)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,3,ach,"rotation_about_direction") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Own fields of RotationAboutDirection
+
+ Handle(StepGeom_Direction) aDirectionOfAxis;
+ data->ReadEntity (num, 2, "direction_of_axis", ach, STANDARD_TYPE(StepGeom_Direction), aDirectionOfAxis);
+
+ Standard_Real aRotationAngle;
+ data->ReadReal (num, 3, "rotation_angle", ach, aRotationAngle);
+
+ // Initialize entity
+ ent->Init(aRepresentationItem_Name,
+ aDirectionOfAxis,
+ aRotationAngle);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWRotationAboutDirection::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_RotationAboutDirection)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Own fields of RotationAboutDirection
+
+ SW.Send (ent->DirectionOfAxis());
+
+ SW.Send (ent->RotationAngle());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWRotationAboutDirection::Share (const Handle(StepKinematics_RotationAboutDirection)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Own fields of RotationAboutDirection
+
+ iter.AddItem (ent->DirectionOfAxis());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_RotationAboutDirection)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_RotationAboutDirection)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_RotationAboutDirection)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWRotationAboutDirection_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWScrewPair.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_ScrewPair)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,7,ach,"screw_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Own fields of ScrewPair
+
+ Standard_Real aPitch;
+ data->ReadReal (num, 7, "pitch", ach, aPitch);
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_ScrewPair)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of ScrewPair
+
+ SW.Send (ent->Pitch());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWScrewPair::Share (const Handle(StepKinematics_ScrewPair)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Own fields of ScrewPair
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_ScrewPair)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_ScrewPair)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_ScrewPair)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWScrewPair_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWScrewPairValue.hxx>
+#include <StepKinematics_ScrewPairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWScrewPairValue
+//purpose :
+//=======================================================================
+
+RWStepKinematics_RWScrewPairValue::RWStepKinematics_RWScrewPairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWScrewPairValue::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_ScrewPairValue)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,2,ach,"screw_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ data->ReadEntity (num, 2, "pair_value.applies_to_pair", ach, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Initialize entity
+ ent->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWScrewPairValue::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_ScrewPairValue)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Own fields of PairValue
+
+ SW.Send (ent->AppliesToPair());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWScrewPairValue::Share (const Handle(StepKinematics_ScrewPairValue)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (ent->StepKinematics_PairValue::AppliesToPair());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_ScrewPairValue)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_ScrewPairValue)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_ScrewPairValue)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWScrewPairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWScrewPairWithRange.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_ScrewPairWithRange)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,9,ach,"screw_pair_with_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of ScrewPair
+
+ Standard_Real aScrewPair_Pitch;
+ data->ReadReal (num, 7, "screw_pair.pitch", ach, aScrewPair_Pitch);
+
+ // Own fields of ScrewPairWithRange
+
+ Standard_Real aLowerLimitActualRotation;
+ Standard_Boolean hasLowerLimitActualRotation = Standard_True;
+ if ( data->IsParamDefined (num,8) ) {
+ data->ReadReal (num, 8, "lower_limit_actual_rotation", ach, aLowerLimitActualRotation);
+ }
+ else {
+ hasLowerLimitActualRotation = Standard_False;
+ aLowerLimitActualRotation = 0;
+ }
+
+ Standard_Real aUpperLimitActualRotation;
+ Standard_Boolean hasUpperLimitActualRotation = Standard_True;
+ if ( data->IsParamDefined (num,9) ) {
+ data->ReadReal (num, 9, "upper_limit_actual_rotation", ach, aUpperLimitActualRotation);
+ }
+ else {
+ hasUpperLimitActualRotation = Standard_False;
+ aUpperLimitActualRotation = 0;
+ }
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_ScrewPairWithRange)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of ScrewPair
+
+ SW.Send (ent->Pitch());
+
+ // Own fields of ScrewPairWithRange
+
+ if ( ent->HasLowerLimitActualRotation() ) {
+ SW.Send (ent->LowerLimitActualRotation());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitActualRotation() ) {
+ SW.Send (ent->UpperLimitActualRotation());
+ }
+ else SW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWScrewPairWithRange::Share (const Handle(StepKinematics_ScrewPairWithRange)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of ScrewPair
+
+ // Own fields of ScrewPairWithRange
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_ScrewPairWithRange)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_ScrewPairWithRange)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_ScrewPairWithRange)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWScrewPairWithRange_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWSlidingCurvePair.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_SlidingCurvePair)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,9,ach,"sliding_curve_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of PlanarCurvePair
+
+ Handle(StepGeom_Curve) aPlanarCurvePair_Curve1;
+ data->ReadEntity (num, 7, "planar_curve_pair.curve1", ach, STANDARD_TYPE(StepGeom_Curve), aPlanarCurvePair_Curve1);
+
+ Handle(StepGeom_Curve) aPlanarCurvePair_Curve2;
+ data->ReadEntity (num, 8, "planar_curve_pair.curve2", ach, STANDARD_TYPE(StepGeom_Curve), aPlanarCurvePair_Curve2);
+
+ Standard_Boolean aPlanarCurvePair_Orientation;
+ data->ReadBoolean (num, 9, "planar_curve_pair.orientation", ach, aPlanarCurvePair_Orientation);
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_SlidingCurvePair)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of PlanarCurvePair
+
+ SW.Send (ent->Curve1());
+
+ SW.Send (ent->Curve2());
+
+ SW.SendBoolean (ent->Orientation());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWSlidingCurvePair::Share (const Handle(StepKinematics_SlidingCurvePair)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of PlanarCurvePair
+
+ iter.AddItem (ent->StepKinematics_PlanarCurvePair::Curve1());
+
+ iter.AddItem (ent->StepKinematics_PlanarCurvePair::Curve2());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_SlidingCurvePair)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_SlidingCurvePair)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_SlidingCurvePair)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWSlidingCurvePair_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWSlidingCurvePairValue.hxx>
+#include <StepKinematics_SlidingCurvePairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWSlidingCurvePairValue
+//purpose :
+//=======================================================================
+
+RWStepKinematics_RWSlidingCurvePairValue::RWStepKinematics_RWSlidingCurvePairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWSlidingCurvePairValue::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_SlidingCurvePairValue)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,2,ach,"sliding_curve_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ data->ReadEntity (num, 2, "pair_value.applies_to_pair", ach, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Initialize entity
+ ent->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWSlidingCurvePairValue::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_SlidingCurvePairValue)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Own fields of PairValue
+
+ SW.Send (ent->AppliesToPair());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWSlidingCurvePairValue::Share (const Handle(StepKinematics_SlidingCurvePairValue)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (ent->StepKinematics_PairValue::AppliesToPair());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_SlidingCurvePairValue)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_SlidingCurvePairValue)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_SlidingCurvePairValue)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWSlidingCurvePairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWSlidingSurfacePair.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_SlidingSurfacePair)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,9,ach,"sliding_surface_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of SurfacePair
+
+ Handle(StepGeom_Surface) aSurfacePair_Surface1;
+ data->ReadEntity (num, 7, "surface_pair.surface1", ach, STANDARD_TYPE(StepGeom_Surface), aSurfacePair_Surface1);
+
+ Handle(StepGeom_Surface) aSurfacePair_Surface2;
+ data->ReadEntity (num, 8, "surface_pair.surface2", ach, STANDARD_TYPE(StepGeom_Surface), aSurfacePair_Surface2);
+
+ Standard_Boolean aSurfacePair_Orientation;
+ data->ReadBoolean (num, 9, "surface_pair.orientation", ach, aSurfacePair_Orientation);
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_SlidingSurfacePair)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of SurfacePair
+
+ SW.Send (ent->Surface1());
+
+ SW.Send (ent->Surface2());
+
+ SW.SendBoolean (ent->Orientation());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWSlidingSurfacePair::Share (const Handle(StepKinematics_SlidingSurfacePair)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of SurfacePair
+
+ iter.AddItem (ent->StepKinematics_SurfacePair::Surface1());
+
+ iter.AddItem (ent->StepKinematics_SurfacePair::Surface2());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_SlidingSurfacePair)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_SlidingSurfacePair)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_SlidingSurfacePair)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWSlidingSurfacePair_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWSlidingSurfacePairValue.hxx>
+#include <StepKinematics_SlidingSurfacePairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWSlidingSurfacePairValue
+//purpose :
+//=======================================================================
+
+RWStepKinematics_RWSlidingSurfacePairValue::RWStepKinematics_RWSlidingSurfacePairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWSlidingSurfacePairValue::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_SlidingSurfacePairValue)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,2,ach,"sliding_surface_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ data->ReadEntity (num, 2, "pair_value.applies_to_pair", ach, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Initialize entity
+ ent->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWSlidingSurfacePairValue::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_SlidingSurfacePairValue)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Own fields of PairValue
+
+ SW.Send (ent->AppliesToPair());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWSlidingSurfacePairValue::Share (const Handle(StepKinematics_SlidingSurfacePairValue)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (ent->StepKinematics_PairValue::AppliesToPair());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_SlidingSurfacePairValue)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_SlidingSurfacePairValue)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_SlidingSurfacePairValue)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWSlidingSurfacePairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWSphericalPair.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_SphericalPair)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,12,ach,"spherical_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ data->ReadBoolean (num, 7, "low_order_kinematic_pair.t_x", ach, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ data->ReadBoolean (num, 8, "low_order_kinematic_pair.t_y", ach, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ data->ReadBoolean (num, 9, "low_order_kinematic_pair.t_z", ach, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ data->ReadBoolean (num, 10, "low_order_kinematic_pair.r_x", ach, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ data->ReadBoolean (num, 11, "low_order_kinematic_pair.r_y", ach, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ data->ReadBoolean (num, 12, "low_order_kinematic_pair.r_z", ach, aLowOrderKinematicPair_RZ);
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_SphericalPair)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ SW.SendBoolean (ent->TX());
+
+ SW.SendBoolean (ent->TY());
+
+ SW.SendBoolean (ent->TZ());
+
+ SW.SendBoolean (ent->RX());
+
+ SW.SendBoolean (ent->RY());
+
+ SW.SendBoolean (ent->RZ());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWSphericalPair::Share (const Handle(StepKinematics_SphericalPair)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_SphericalPair)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_SphericalPair)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_SphericalPair)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWSphericalPair_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWSphericalPairValue.hxx>
+#include <StepKinematics_SphericalPairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWSphericalPairValue
+//purpose :
+//=======================================================================
+
+RWStepKinematics_RWSphericalPairValue::RWStepKinematics_RWSphericalPairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWSphericalPairValue::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_SphericalPairValue)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,2,ach,"spherical_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ data->ReadEntity (num, 2, "pair_value.applies_to_pair", ach, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Initialize entity
+ ent->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWSphericalPairValue::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_SphericalPairValue)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Own fields of PairValue
+
+ SW.Send (ent->AppliesToPair());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWSphericalPairValue::Share (const Handle(StepKinematics_SphericalPairValue)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (ent->StepKinematics_PairValue::AppliesToPair());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_SphericalPairValue)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_SphericalPairValue)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_SphericalPairValue)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWSphericalPairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWSphericalPairWithPin.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_SphericalPairWithPin)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,12,ach,"spherical_pair_with_pin") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ data->ReadBoolean (num, 7, "low_order_kinematic_pair.t_x", ach, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ data->ReadBoolean (num, 8, "low_order_kinematic_pair.t_y", ach, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ data->ReadBoolean (num, 9, "low_order_kinematic_pair.t_z", ach, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ data->ReadBoolean (num, 10, "low_order_kinematic_pair.r_x", ach, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ data->ReadBoolean (num, 11, "low_order_kinematic_pair.r_y", ach, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ data->ReadBoolean (num, 12, "low_order_kinematic_pair.r_z", ach, aLowOrderKinematicPair_RZ);
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_SphericalPairWithPin)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ SW.SendBoolean (ent->TX());
+
+ SW.SendBoolean (ent->TY());
+
+ SW.SendBoolean (ent->TZ());
+
+ SW.SendBoolean (ent->RX());
+
+ SW.SendBoolean (ent->RY());
+
+ SW.SendBoolean (ent->RZ());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWSphericalPairWithPin::Share (const Handle(StepKinematics_SphericalPairWithPin)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_SphericalPairWithPin)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_SphericalPairWithPin)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_SphericalPairWithPin)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWSphericalPairWithPin_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWSphericalPairWithPinAndRange.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_SphericalPairWithPinAndRange)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,16,ach,"spherical_pair_with_pin_and_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ data->ReadBoolean (num, 7, "low_order_kinematic_pair.t_x", ach, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ data->ReadBoolean (num, 8, "low_order_kinematic_pair.t_y", ach, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ data->ReadBoolean (num, 9, "low_order_kinematic_pair.t_z", ach, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ data->ReadBoolean (num, 10, "low_order_kinematic_pair.r_x", ach, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ data->ReadBoolean (num, 11, "low_order_kinematic_pair.r_y", ach, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ data->ReadBoolean (num, 12, "low_order_kinematic_pair.r_z", ach, aLowOrderKinematicPair_RZ);
+
+ // Own fields of SphericalPairWithPinAndRange
+
+ Standard_Real aLowerLimitYaw;
+ Standard_Boolean hasLowerLimitYaw = Standard_True;
+ if ( data->IsParamDefined (num,13) ) {
+ data->ReadReal (num, 13, "lower_limit_yaw", ach, aLowerLimitYaw);
+ }
+ else {
+ hasLowerLimitYaw = Standard_False;
+ aLowerLimitYaw = 0;
+ }
+
+ Standard_Real aUpperLimitYaw;
+ Standard_Boolean hasUpperLimitYaw = Standard_True;
+ if ( data->IsParamDefined (num,14) ) {
+ data->ReadReal (num, 14, "upper_limit_yaw", ach, aUpperLimitYaw);
+ }
+ else {
+ hasUpperLimitYaw = Standard_False;
+ aUpperLimitYaw = 0;
+ }
+
+ Standard_Real aLowerLimitRoll;
+ Standard_Boolean hasLowerLimitRoll = Standard_True;
+ if ( data->IsParamDefined (num,15) ) {
+ data->ReadReal (num, 15, "lower_limit_roll", ach, aLowerLimitRoll);
+ }
+ else {
+ hasLowerLimitRoll = Standard_False;
+ aLowerLimitRoll = 0;
+ }
+
+ Standard_Real aUpperLimitRoll;
+ Standard_Boolean hasUpperLimitRoll = Standard_True;
+ if ( data->IsParamDefined (num,16) ) {
+ data->ReadReal (num, 16, "upper_limit_roll", ach, aUpperLimitRoll);
+ }
+ else {
+ hasUpperLimitRoll = Standard_False;
+ aUpperLimitRoll = 0;
+ }
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_SphericalPairWithPinAndRange)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ SW.SendBoolean (ent->TX());
+
+ SW.SendBoolean (ent->TY());
+
+ SW.SendBoolean (ent->TZ());
+
+ SW.SendBoolean (ent->RX());
+
+ SW.SendBoolean (ent->RY());
+
+ SW.SendBoolean (ent->RZ());
+
+ // Own fields of SphericalPairWithPinAndRange
+
+ if ( ent->HasLowerLimitYaw() ) {
+ SW.Send (ent->LowerLimitYaw());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitYaw() ) {
+ SW.Send (ent->UpperLimitYaw());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasLowerLimitRoll() ) {
+ SW.Send (ent->LowerLimitRoll());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitRoll() ) {
+ SW.Send (ent->UpperLimitRoll());
+ }
+ else SW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWSphericalPairWithPinAndRange::Share (const Handle(StepKinematics_SphericalPairWithPinAndRange)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+
+ // Own fields of SphericalPairWithPinAndRange
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_SphericalPairWithPinAndRange)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_SphericalPairWithPinAndRange)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_SphericalPairWithPinAndRange)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWSphericalPairWithPinAndRange_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWSphericalPairWithRange.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_SphericalPairWithRange)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,18,ach,"spherical_pair_with_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ data->ReadBoolean (num, 7, "low_order_kinematic_pair.t_x", ach, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ data->ReadBoolean (num, 8, "low_order_kinematic_pair.t_y", ach, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ data->ReadBoolean (num, 9, "low_order_kinematic_pair.t_z", ach, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ data->ReadBoolean (num, 10, "low_order_kinematic_pair.r_x", ach, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ data->ReadBoolean (num, 11, "low_order_kinematic_pair.r_y", ach, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ data->ReadBoolean (num, 12, "low_order_kinematic_pair.r_z", ach, aLowOrderKinematicPair_RZ);
+
+ // Own fields of SphericalPairWithRange
+
+ Standard_Real aLowerLimitYaw;
+ Standard_Boolean hasLowerLimitYaw = Standard_True;
+ if ( data->IsParamDefined (num,13) ) {
+ data->ReadReal (num, 13, "lower_limit_yaw", ach, aLowerLimitYaw);
+ }
+ else {
+ hasLowerLimitYaw = Standard_False;
+ aLowerLimitYaw = 0;
+ }
+
+ Standard_Real aUpperLimitYaw;
+ Standard_Boolean hasUpperLimitYaw = Standard_True;
+ if ( data->IsParamDefined (num,14) ) {
+ data->ReadReal (num, 14, "upper_limit_yaw", ach, aUpperLimitYaw);
+ }
+ else {
+ hasUpperLimitYaw = Standard_False;
+ aUpperLimitYaw = 0;
+ }
+
+ Standard_Real aLowerLimitPitch;
+ Standard_Boolean hasLowerLimitPitch = Standard_True;
+ if ( data->IsParamDefined (num,15) ) {
+ data->ReadReal (num, 15, "lower_limit_pitch", ach, aLowerLimitPitch);
+ }
+ else {
+ hasLowerLimitPitch = Standard_False;
+ aLowerLimitPitch = 0;
+ }
+
+ Standard_Real aUpperLimitPitch;
+ Standard_Boolean hasUpperLimitPitch = Standard_True;
+ if ( data->IsParamDefined (num,16) ) {
+ data->ReadReal (num, 16, "upper_limit_pitch", ach, aUpperLimitPitch);
+ }
+ else {
+ hasUpperLimitPitch = Standard_False;
+ aUpperLimitPitch = 0;
+ }
+
+ Standard_Real aLowerLimitRoll;
+ Standard_Boolean hasLowerLimitRoll = Standard_True;
+ if ( data->IsParamDefined (num,17) ) {
+ data->ReadReal (num, 17, "lower_limit_roll", ach, aLowerLimitRoll);
+ }
+ else {
+ hasLowerLimitRoll = Standard_False;
+ aLowerLimitRoll = 0;
+ }
+
+ Standard_Real aUpperLimitRoll;
+ Standard_Boolean hasUpperLimitRoll = Standard_True;
+ if ( data->IsParamDefined (num,18) ) {
+ data->ReadReal (num, 18, "upper_limit_roll", ach, aUpperLimitRoll);
+ }
+ else {
+ hasUpperLimitRoll = Standard_False;
+ aUpperLimitRoll = 0;
+ }
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_SphericalPairWithRange)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ SW.SendBoolean (ent->TX());
+
+ SW.SendBoolean (ent->TY());
+
+ SW.SendBoolean (ent->TZ());
+
+ SW.SendBoolean (ent->RX());
+
+ SW.SendBoolean (ent->RY());
+
+ SW.SendBoolean (ent->RZ());
+
+ // Own fields of SphericalPairWithRange
+
+ if ( ent->HasLowerLimitYaw() ) {
+ SW.Send (ent->LowerLimitYaw());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitYaw() ) {
+ SW.Send (ent->UpperLimitYaw());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasLowerLimitPitch() ) {
+ SW.Send (ent->LowerLimitPitch());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitPitch() ) {
+ SW.Send (ent->UpperLimitPitch());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasLowerLimitRoll() ) {
+ SW.Send (ent->LowerLimitRoll());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitRoll() ) {
+ SW.Send (ent->UpperLimitRoll());
+ }
+ else SW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWSphericalPairWithRange::Share (const Handle(StepKinematics_SphericalPairWithRange)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+
+ // Own fields of SphericalPairWithRange
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_SphericalPairWithRange)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_SphericalPairWithRange)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_SphericalPairWithRange)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWSphericalPairWithRange_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWSuParameters.hxx>
+#include <StepKinematics_SuParameters.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWSuParameters
+//purpose :
+//=======================================================================
+
+RWStepKinematics_RWSuParameters::RWStepKinematics_RWSuParameters() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWSuParameters::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_SuParameters)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,7,ach,"su_parameters") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Own fields of SuParameters
+
+ Standard_Real aA;
+ data->ReadReal (num, 2, "a", ach, aA);
+
+ Standard_Real aAlpha;
+ data->ReadReal (num, 3, "alpha", ach, aAlpha);
+
+ Standard_Real aB;
+ data->ReadReal (num, 4, "b", ach, aB);
+
+ Standard_Real aBeta;
+ data->ReadReal (num, 5, "beta", ach, aBeta);
+
+ Standard_Real aC;
+ data->ReadReal (num, 6, "c", ach, aC);
+
+ Standard_Real aGamma;
+ data->ReadReal (num, 7, "gamma", ach, aGamma);
+
+ // Initialize entity
+ ent->Init(aRepresentationItem_Name,
+ aA,
+ aAlpha,
+ aB,
+ aBeta,
+ aC,
+ aGamma);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWSuParameters::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_SuParameters)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Own fields of SuParameters
+
+ SW.Send (ent->A());
+
+ SW.Send (ent->Alpha());
+
+ SW.Send (ent->B());
+
+ SW.Send (ent->Beta());
+
+ SW.Send (ent->C());
+
+ SW.Send (ent->Gamma());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWSuParameters::Share (const Handle(StepKinematics_SuParameters)& /*ent*/,
+ Interface_EntityIterator& /*iter*/) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Own fields of SuParameters
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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_RWSuParameters_HeaderFile_
+#define _RWStepKinematics_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 StepKinematics_SuParameters;
+
+//! Read & Write tool for SuParameters
+class RWStepKinematics_RWSuParameters
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ Standard_EXPORT RWStepKinematics_RWSuParameters();
+
+ Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_SuParameters)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_SuParameters)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_SuParameters)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWSuParameters_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWSurfacePairWithRange.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_SurfacePairWithRange)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,13,ach,"surface_pair_with_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of SurfacePair
+
+ Handle(StepGeom_Surface) aSurfacePair_Surface1;
+ data->ReadEntity (num, 7, "surface_pair.surface1", ach, STANDARD_TYPE(StepGeom_Surface), aSurfacePair_Surface1);
+
+ Handle(StepGeom_Surface) aSurfacePair_Surface2;
+ data->ReadEntity (num, 8, "surface_pair.surface2", ach, STANDARD_TYPE(StepGeom_Surface), aSurfacePair_Surface2);
+
+ Standard_Boolean aSurfacePair_Orientation;
+ data->ReadBoolean (num, 9, "surface_pair.orientation", ach, aSurfacePair_Orientation);
+
+ // Own fields of SurfacePairWithRange
+
+ Handle(StepGeom_RectangularTrimmedSurface) aRangeOnSurface1;
+ data->ReadEntity (num, 10, "range_on_surface1", ach, STANDARD_TYPE(StepGeom_RectangularTrimmedSurface), aRangeOnSurface1);
+
+ Handle(StepGeom_RectangularTrimmedSurface) aRangeOnSurface2;
+ data->ReadEntity (num, 11, "range_on_surface2", ach, STANDARD_TYPE(StepGeom_RectangularTrimmedSurface), aRangeOnSurface2);
+
+ Standard_Real aLowerLimitActualRotation;
+ Standard_Boolean hasLowerLimitActualRotation = Standard_True;
+ if ( data->IsParamDefined (num,12) ) {
+ data->ReadReal (num, 12, "lower_limit_actual_rotation", ach, aLowerLimitActualRotation);
+ }
+ else {
+ hasLowerLimitActualRotation = Standard_False;
+ aLowerLimitActualRotation = 0;
+ }
+
+ Standard_Real aUpperLimitActualRotation;
+ Standard_Boolean hasUpperLimitActualRotation = Standard_True;
+ if ( data->IsParamDefined (num,13) ) {
+ data->ReadReal (num, 13, "upper_limit_actual_rotation", ach, aUpperLimitActualRotation);
+ }
+ else {
+ hasUpperLimitActualRotation = Standard_False;
+ aUpperLimitActualRotation = 0;
+ }
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_SurfacePairWithRange)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of SurfacePair
+
+ SW.Send (ent->Surface1());
+
+ SW.Send (ent->Surface2());
+
+ SW.SendBoolean (ent->Orientation());
+
+ // Own fields of SurfacePairWithRange
+
+ SW.Send (ent->RangeOnSurface1());
+
+ SW.Send (ent->RangeOnSurface2());
+
+ if ( ent->HasLowerLimitActualRotation() ) {
+ SW.Send (ent->LowerLimitActualRotation());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitActualRotation() ) {
+ SW.Send (ent->UpperLimitActualRotation());
+ }
+ else SW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWSurfacePairWithRange::Share (const Handle(StepKinematics_SurfacePairWithRange)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of SurfacePair
+
+ iter.AddItem (ent->StepKinematics_SurfacePair::Surface1());
+
+ iter.AddItem (ent->StepKinematics_SurfacePair::Surface2());
+
+ // Own fields of SurfacePairWithRange
+
+ iter.AddItem (ent->RangeOnSurface1());
+
+ iter.AddItem (ent->RangeOnSurface2());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_SurfacePairWithRange)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_SurfacePairWithRange)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_SurfacePairWithRange)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWSurfacePairWithRange_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWUnconstrainedPair.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_UnconstrainedPair)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,12,ach,"unconstrained_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ data->ReadBoolean (num, 7, "low_order_kinematic_pair.t_x", ach, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ data->ReadBoolean (num, 8, "low_order_kinematic_pair.t_y", ach, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ data->ReadBoolean (num, 9, "low_order_kinematic_pair.t_z", ach, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ data->ReadBoolean (num, 10, "low_order_kinematic_pair.r_x", ach, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ data->ReadBoolean (num, 11, "low_order_kinematic_pair.r_y", ach, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ data->ReadBoolean (num, 12, "low_order_kinematic_pair.r_z", ach, aLowOrderKinematicPair_RZ);
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_UnconstrainedPair)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ SW.SendBoolean (ent->TX());
+
+ SW.SendBoolean (ent->TY());
+
+ SW.SendBoolean (ent->TZ());
+
+ SW.SendBoolean (ent->RX());
+
+ SW.SendBoolean (ent->RY());
+
+ SW.SendBoolean (ent->RZ());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWUnconstrainedPair::Share (const Handle(StepKinematics_UnconstrainedPair)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_UnconstrainedPair)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_UnconstrainedPair)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_UnconstrainedPair)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWUnconstrainedPair_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWUnconstrainedPairValue.hxx>
+#include <StepKinematics_UnconstrainedPairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWUnconstrainedPairValue
+//purpose :
+//=======================================================================
+
+RWStepKinematics_RWUnconstrainedPairValue::RWStepKinematics_RWUnconstrainedPairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWUnconstrainedPairValue::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_UnconstrainedPairValue)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,2,ach,"unconstrained_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ data->ReadEntity (num, 2, "pair_value.applies_to_pair", ach, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Initialize entity
+ ent->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWUnconstrainedPairValue::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_UnconstrainedPairValue)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Own fields of PairValue
+
+ SW.Send (ent->AppliesToPair());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWUnconstrainedPairValue::Share (const Handle(StepKinematics_UnconstrainedPairValue)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (ent->StepKinematics_PairValue::AppliesToPair());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_UnconstrainedPairValue)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_UnconstrainedPairValue)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_UnconstrainedPairValue)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWUnconstrainedPairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWUniversalPair.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_UniversalPair)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,13,ach,"universal_pair") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ data->ReadBoolean (num, 7, "low_order_kinematic_pair.t_x", ach, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ data->ReadBoolean (num, 8, "low_order_kinematic_pair.t_y", ach, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ data->ReadBoolean (num, 9, "low_order_kinematic_pair.t_z", ach, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ data->ReadBoolean (num, 10, "low_order_kinematic_pair.r_x", ach, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ data->ReadBoolean (num, 11, "low_order_kinematic_pair.r_y", ach, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ data->ReadBoolean (num, 12, "low_order_kinematic_pair.r_z", ach, aLowOrderKinematicPair_RZ);
+
+ // Own fields of UniversalPair
+
+ Standard_Real aInputSkewAngle;
+ Standard_Boolean hasInputSkewAngle = Standard_True;
+ if ( data->IsParamDefined (num,13) ) {
+ data->ReadReal (num, 13, "input_skew_angle", ach, aInputSkewAngle);
+ }
+ else {
+ hasInputSkewAngle = Standard_False;
+ aInputSkewAngle = 0;
+ }
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_UniversalPair)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ SW.SendBoolean (ent->TX());
+
+ SW.SendBoolean (ent->TY());
+
+ SW.SendBoolean (ent->TZ());
+
+ SW.SendBoolean (ent->RX());
+
+ SW.SendBoolean (ent->RY());
+
+ SW.SendBoolean (ent->RZ());
+
+ // Own fields of UniversalPair
+
+ if ( ent->HasInputSkewAngle() ) {
+ SW.Send (ent->InputSkewAngle());
+ }
+ else SW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWUniversalPair::Share (const Handle(StepKinematics_UniversalPair)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+
+ // Own fields of UniversalPair
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_UniversalPair)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_UniversalPair)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_UniversalPair)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWUniversalPair_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWUniversalPairValue.hxx>
+#include <StepKinematics_UniversalPairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWUniversalPairValue
+//purpose :
+//=======================================================================
+
+RWStepKinematics_RWUniversalPairValue::RWStepKinematics_RWUniversalPairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWUniversalPairValue::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_UniversalPairValue)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,2,ach,"universal_pair_value") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of PairValue
+
+ Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+ data->ReadEntity (num, 2, "pair_value.applies_to_pair", ach, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+ // Initialize entity
+ ent->Init(aRepresentationItem_Name,
+ aPairValue_AppliesToPair);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWUniversalPairValue::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepKinematics_UniversalPairValue)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Own fields of PairValue
+
+ SW.Send (ent->AppliesToPair());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWUniversalPairValue::Share (const Handle(StepKinematics_UniversalPairValue)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of PairValue
+
+ iter.AddItem (ent->StepKinematics_PairValue::AppliesToPair());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_UniversalPairValue)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_UniversalPairValue)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_UniversalPairValue)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWUniversalPairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepKinematics_RWUniversalPairWithRange.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepKinematics_UniversalPairWithRange)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,17,ach,"universal_pair_with_range") ) return;
+
+ // Inherited fields of RepresentationItem
+
+ Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+ data->ReadString (num, 1, "representation_item.name", ach, aRepresentationItem_Name);
+
+ // Inherited fields of ItemDefinedTransformation
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+ data->ReadString (num, 2, "item_defined_transformation.name", ach, aItemDefinedTransformation_Name);
+
+ Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+ Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+ if ( data->IsParamDefined (num,3) ) {
+ data->ReadString (num, 3, "item_defined_transformation.description", ach, aItemDefinedTransformation_Description);
+ }
+ else {
+ hasItemDefinedTransformation_Description = Standard_False;
+ aItemDefinedTransformation_Description.Nullify();
+ }
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+ data->ReadEntity (num, 4, "item_defined_transformation.transform_item1", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+ Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+ data->ReadEntity (num, 5, "item_defined_transformation.transform_item2", ach, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+ // Inherited fields of KinematicPair
+
+ Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+ data->ReadEntity (num, 6, "kinematic_pair.joint", ach, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+ // Inherited fields of LowOrderKinematicPair
+
+ Standard_Boolean aLowOrderKinematicPair_TX;
+ data->ReadBoolean (num, 7, "low_order_kinematic_pair.t_x", ach, aLowOrderKinematicPair_TX);
+
+ Standard_Boolean aLowOrderKinematicPair_TY;
+ data->ReadBoolean (num, 8, "low_order_kinematic_pair.t_y", ach, aLowOrderKinematicPair_TY);
+
+ Standard_Boolean aLowOrderKinematicPair_TZ;
+ data->ReadBoolean (num, 9, "low_order_kinematic_pair.t_z", ach, aLowOrderKinematicPair_TZ);
+
+ Standard_Boolean aLowOrderKinematicPair_RX;
+ data->ReadBoolean (num, 10, "low_order_kinematic_pair.r_x", ach, aLowOrderKinematicPair_RX);
+
+ Standard_Boolean aLowOrderKinematicPair_RY;
+ data->ReadBoolean (num, 11, "low_order_kinematic_pair.r_y", ach, aLowOrderKinematicPair_RY);
+
+ Standard_Boolean aLowOrderKinematicPair_RZ;
+ data->ReadBoolean (num, 12, "low_order_kinematic_pair.r_z", ach, aLowOrderKinematicPair_RZ);
+
+ // Inherited fields of UniversalPair
+
+ Standard_Real aUniversalPair_InputSkewAngle;
+ Standard_Boolean hasUniversalPair_InputSkewAngle = Standard_True;
+ if ( data->IsParamDefined (num,13) ) {
+ data->ReadReal (num, 13, "universal_pair.input_skew_angle", ach, aUniversalPair_InputSkewAngle);
+ }
+ else {
+ hasUniversalPair_InputSkewAngle = Standard_False;
+ aUniversalPair_InputSkewAngle = 0;
+ }
+
+ // Own fields of UniversalPairWithRange
+
+ Standard_Real aLowerLimitFirstRotation;
+ Standard_Boolean hasLowerLimitFirstRotation = Standard_True;
+ if ( data->IsParamDefined (num,14) ) {
+ data->ReadReal (num, 14, "lower_limit_first_rotation", ach, aLowerLimitFirstRotation);
+ }
+ else {
+ hasLowerLimitFirstRotation = Standard_False;
+ aLowerLimitFirstRotation = 0;
+ }
+
+ Standard_Real aUpperLimitFirstRotation;
+ Standard_Boolean hasUpperLimitFirstRotation = Standard_True;
+ if ( data->IsParamDefined (num,15) ) {
+ data->ReadReal (num, 15, "upper_limit_first_rotation", ach, aUpperLimitFirstRotation);
+ }
+ else {
+ hasUpperLimitFirstRotation = Standard_False;
+ aUpperLimitFirstRotation = 0;
+ }
+
+ Standard_Real aLowerLimitSecondRotation;
+ Standard_Boolean hasLowerLimitSecondRotation = Standard_True;
+ if ( data->IsParamDefined (num,16) ) {
+ data->ReadReal (num, 16, "lower_limit_second_rotation", ach, aLowerLimitSecondRotation);
+ }
+ else {
+ hasLowerLimitSecondRotation = Standard_False;
+ aLowerLimitSecondRotation = 0;
+ }
+
+ Standard_Real aUpperLimitSecondRotation;
+ Standard_Boolean hasUpperLimitSecondRotation = Standard_True;
+ if ( data->IsParamDefined (num,17) ) {
+ data->ReadReal (num, 17, "upper_limit_second_rotation", ach, aUpperLimitSecondRotation);
+ }
+ else {
+ hasUpperLimitSecondRotation = Standard_False;
+ aUpperLimitSecondRotation = 0;
+ }
+
+ // Initialize entity
+ ent->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& SW,
+ const Handle(StepKinematics_UniversalPairWithRange)& ent) const
+{
+
+ // Own fields of RepresentationItem
+
+ SW.Send (ent->Name());
+
+ // Inherited fields of ItemDefinedTransformation
+
+ SW.Send (ent->ItemDefinedTransformation()->Name());
+
+ if ( ent->ItemDefinedTransformation()->HasDescription() ) {
+ SW.Send (ent->ItemDefinedTransformation()->Description());
+ }
+ else SW.SendUndef();
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem1());
+
+ SW.Send (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Own fields of KinematicPair
+
+ SW.Send (ent->Joint());
+
+ // Own fields of LowOrderKinematicPair
+
+ SW.SendBoolean (ent->TX());
+
+ SW.SendBoolean (ent->TY());
+
+ SW.SendBoolean (ent->TZ());
+
+ SW.SendBoolean (ent->RX());
+
+ SW.SendBoolean (ent->RY());
+
+ SW.SendBoolean (ent->RZ());
+
+ // Own fields of UniversalPair
+
+ if ( ent->HasInputSkewAngle() ) {
+ SW.Send (ent->InputSkewAngle());
+ }
+ else SW.SendUndef();
+
+ // Own fields of UniversalPairWithRange
+
+ if ( ent->HasLowerLimitFirstRotation() ) {
+ SW.Send (ent->LowerLimitFirstRotation());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitFirstRotation() ) {
+ SW.Send (ent->UpperLimitFirstRotation());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasLowerLimitSecondRotation() ) {
+ SW.Send (ent->LowerLimitSecondRotation());
+ }
+ else SW.SendUndef();
+
+ if ( ent->HasUpperLimitSecondRotation() ) {
+ SW.Send (ent->UpperLimitSecondRotation());
+ }
+ else SW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepKinematics_RWUniversalPairWithRange::Share (const Handle(StepKinematics_UniversalPairWithRange)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of RepresentationItem
+
+ // Inherited fields of ItemDefinedTransformation
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem1());
+
+ iter.AddItem (ent->ItemDefinedTransformation()->TransformItem2());
+
+ // Inherited fields of KinematicPair
+
+ iter.AddItem (ent->StepKinematics_KinematicPair::Joint());
+
+ // Inherited fields of LowOrderKinematicPair
+
+ // Inherited fields of UniversalPair
+
+ // Own fields of UniversalPairWithRange
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepKinematics_UniversalPairWithRange)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepKinematics_UniversalPairWithRange)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepKinematics_UniversalPairWithRange)& ent, 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepRepr_RWRepresentationContextReference.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepRepr_RepresentationContextReference)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,1,ach,"representation_context_reference") ) return;
+
+ // Own fields of RepresentationContextReference
+
+ Handle(TCollection_HAsciiString) aContextIdentifier;
+ data->ReadString (num, 1, "context_identifier", ach, aContextIdentifier);
+
+ // Initialize entity
+ ent->Init(aContextIdentifier);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWRepresentationContextReference::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepRepr_RepresentationContextReference)& ent) const
+{
+
+ // Own fields of RepresentationContextReference
+
+ SW.Send (ent->ContextIdentifier());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWRepresentationContextReference::Share (const Handle(StepRepr_RepresentationContextReference)& /*ent*/,
+ Interface_EntityIterator& /*iter*/) const
+{
+
+ // Own fields of RepresentationContextReference
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepRepr_RepresentationContextReference)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepRepr_RepresentationContextReference)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepRepr_RepresentationContextReference)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepRepr_RWRepresentationContextReference_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <RWStepRepr_RWRepresentationReference.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)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepRepr_RepresentationReference)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,2,ach,"representation_reference") ) return;
+
+ // Own fields of RepresentationReference
+
+ Handle(TCollection_HAsciiString) aId;
+ data->ReadString (num, 1, "id", ach, aId);
+
+ Handle(StepRepr_RepresentationContextReference) aContextOfItems;
+ data->ReadEntity (num, 2, "context_of_items", ach, STANDARD_TYPE(StepRepr_RepresentationContextReference), aContextOfItems);
+
+ // Initialize entity
+ ent->Init(aId,
+ aContextOfItems);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWRepresentationReference::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepRepr_RepresentationReference)& ent) const
+{
+
+ // Own fields of RepresentationReference
+
+ SW.Send (ent->Id());
+
+ SW.Send (ent->ContextOfItems());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWRepresentationReference::Share (const Handle(StepRepr_RepresentationReference)& ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Own fields of RepresentationReference
+
+ iter.AddItem (ent->ContextOfItems());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepRepr_RepresentationReference)& ent) const;
+
+ Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepRepr_RepresentationReference)& ent) const;
+
+ Standard_EXPORT void Share(const Handle(StepRepr_RepresentationReference)& ent, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepRepr_RWRepresentationReference_HeaderFile_
#include <StepVisual_CameraModelD3MultiClippingIntersection.hxx>
#include <StepVisual_CameraModelD3MultiClippingUnion.hxx>
#include <StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem.hxx>
+// Added for kinematics implementation
+#include <StepRepr_RepresentationContextReference.hxx>
+#include <StepRepr_RepresentationReference.hxx>
+#include <StepKinematics_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_KinematicTopologyStructure.hxx>
+#include <StepKinematics_LowOrderKinematicPair.hxx>
+#include <StepKinematics_LowOrderKinematicPairValue.hxx>
+#include <StepKinematics_LowOrderKinematicPairWithRange.hxx>
+#include <StepKinematics_MechanismRepresentation.hxx>
+#include <StepKinematics_OrientedJoint.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_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>
+
static int THE_StepAP214_Protocol_init = 0;
static Interface_DataMapOfTransientInteger types(800);
types.Bind (STANDARD_TYPE(StepVisual_CameraModelD3MultiClippingIntersection), 717);
types.Bind (STANDARD_TYPE(StepVisual_CameraModelD3MultiClippingUnion), 718);
types.Bind (STANDARD_TYPE(StepVisual_AnnotationCurveOccurrenceAndAnnotationOccurrenceAndGeomReprItemAndReprItemAndStyledItem), 719);
+
+ // Added for kinematics implementation
+ types.Bind(STANDARD_TYPE(StepRepr_RepresentationContextReference), 720);
+ types.Bind(STANDARD_TYPE(StepRepr_RepresentationReference), 721);
+ types.Bind(STANDARD_TYPE(StepKinematics_SuParameters), 722);
+ types.Bind(STANDARD_TYPE(StepKinematics_RotationAboutDirection), 723);
+ types.Bind(STANDARD_TYPE(StepKinematics_KinematicJoint), 724);
+ types.Bind(STANDARD_TYPE(StepKinematics_ActuatedKinematicPair), 725);
+ types.Bind(STANDARD_TYPE(StepKinematics_ContextDependentKinematicLinkRepresentation), 726);
+ types.Bind(STANDARD_TYPE(StepKinematics_CylindricalPair), 727);
+ types.Bind(STANDARD_TYPE(StepKinematics_CylindricalPairValue), 728);
+ types.Bind(STANDARD_TYPE(StepKinematics_CylindricalPairWithRange), 729);
+ types.Bind(STANDARD_TYPE(StepKinematics_FullyConstrainedPair), 730);
+ types.Bind(STANDARD_TYPE(StepKinematics_GearPair), 731);
+ types.Bind(STANDARD_TYPE(StepKinematics_GearPairValue), 732);
+ types.Bind(STANDARD_TYPE(StepKinematics_GearPairWithRange), 733);
+ types.Bind(STANDARD_TYPE(StepKinematics_HomokineticPair), 734);
+ types.Bind(STANDARD_TYPE(StepKinematics_KinematicLink), 735);
+ types.Bind(STANDARD_TYPE(StepKinematics_KinematicLinkRepresentationAssociation), 736);
+ types.Bind(STANDARD_TYPE(StepKinematics_KinematicPropertyMechanismRepresentation), 737);
+ types.Bind(STANDARD_TYPE(StepKinematics_KinematicTopologyStructure), 738);
+ types.Bind(STANDARD_TYPE(StepKinematics_LowOrderKinematicPair), 739);
+ types.Bind(STANDARD_TYPE(StepKinematics_LowOrderKinematicPairValue), 740);
+ types.Bind(STANDARD_TYPE(StepKinematics_LowOrderKinematicPairWithRange), 741);
+ types.Bind(STANDARD_TYPE(StepKinematics_MechanismRepresentation), 742);
+ types.Bind(STANDARD_TYPE(StepKinematics_OrientedJoint), 743);
+ types.Bind(STANDARD_TYPE(StepKinematics_PlanarCurvePair), 744);
+ types.Bind(STANDARD_TYPE(StepKinematics_PlanarCurvePairRange), 745);
+ types.Bind(STANDARD_TYPE(StepKinematics_PlanarPair), 746);
+ types.Bind(STANDARD_TYPE(StepKinematics_PlanarPairValue), 747);
+ types.Bind(STANDARD_TYPE(StepKinematics_PlanarPairWithRange), 748);
+ types.Bind(STANDARD_TYPE(StepKinematics_PointOnPlanarCurvePair), 749);
+ types.Bind(STANDARD_TYPE(StepKinematics_PointOnPlanarCurvePairValue), 750);
+ types.Bind(STANDARD_TYPE(StepKinematics_PointOnPlanarCurvePairWithRange), 751);
+ types.Bind(STANDARD_TYPE(StepKinematics_PointOnSurfacePair), 752);
+ types.Bind(STANDARD_TYPE(StepKinematics_PointOnSurfacePairValue), 753);
+ types.Bind(STANDARD_TYPE(StepKinematics_PointOnSurfacePairWithRange), 754);
+ types.Bind(STANDARD_TYPE(StepKinematics_PrismaticPair), 755);
+ types.Bind(STANDARD_TYPE(StepKinematics_PrismaticPairValue), 756);
+ types.Bind(STANDARD_TYPE(StepKinematics_PrismaticPairWithRange), 757);
+ types.Bind(STANDARD_TYPE(StepKinematics_ProductDefinitionKinematics), 758);
+ types.Bind(STANDARD_TYPE(StepKinematics_ProductDefinitionRelationshipKinematics), 759);
+ types.Bind(STANDARD_TYPE(StepKinematics_RackAndPinionPair), 760);
+ types.Bind(STANDARD_TYPE(StepKinematics_RackAndPinionPairValue), 761);
+ types.Bind(STANDARD_TYPE(StepKinematics_RackAndPinionPairWithRange), 762);
+ types.Bind(STANDARD_TYPE(StepKinematics_RevolutePair), 763);
+ types.Bind(STANDARD_TYPE(StepKinematics_RevolutePairValue), 764);
+ types.Bind(STANDARD_TYPE(StepKinematics_RevolutePairWithRange), 765);
+ types.Bind(STANDARD_TYPE(StepKinematics_RollingCurvePair), 766);
+ types.Bind(STANDARD_TYPE(StepKinematics_RollingCurvePairValue), 767);
+ types.Bind(STANDARD_TYPE(StepKinematics_RollingSurfacePair), 768);
+ types.Bind(STANDARD_TYPE(StepKinematics_RollingSurfacePairValue), 769);
+ types.Bind(STANDARD_TYPE(StepKinematics_ScrewPair), 770);
+ types.Bind(STANDARD_TYPE(StepKinematics_ScrewPairValue), 771);
+ types.Bind(STANDARD_TYPE(StepKinematics_ScrewPairWithRange), 772);
+ types.Bind(STANDARD_TYPE(StepKinematics_SlidingCurvePair), 773);
+ types.Bind(STANDARD_TYPE(StepKinematics_SlidingCurvePairValue), 774);
+ types.Bind(STANDARD_TYPE(StepKinematics_SlidingSurfacePair), 775);
+ types.Bind(STANDARD_TYPE(StepKinematics_SlidingSurfacePairValue), 776);
+ types.Bind(STANDARD_TYPE(StepKinematics_SphericalPair), 777);
+ types.Bind(STANDARD_TYPE(StepKinematics_SphericalPairValue), 778);
+ types.Bind(STANDARD_TYPE(StepKinematics_SphericalPairWithPin), 779);
+ types.Bind(STANDARD_TYPE(StepKinematics_SphericalPairWithPinAndRange), 780);
+ types.Bind(STANDARD_TYPE(StepKinematics_SphericalPairWithRange), 781);
+ types.Bind(STANDARD_TYPE(StepKinematics_SurfacePairWithRange), 782);
+ types.Bind(STANDARD_TYPE(StepKinematics_UnconstrainedPair), 783);
+ types.Bind(STANDARD_TYPE(StepKinematics_UnconstrainedPairValue), 784);
+ types.Bind(STANDARD_TYPE(StepKinematics_UniversalPair), 785);
+ types.Bind(STANDARD_TYPE(StepKinematics_UniversalPairValue), 786);
+ types.Bind(STANDARD_TYPE(StepKinematics_UniversalPairWithRange), 787);
+
}
--- /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_KinematicPropertyDefinitionRepresentation.cxx
+StepKinematics_KinematicPropertyDefinitionRepresentation.hxx
+StepKinematics_KinematicPropertyMechanismRepresentation.cxx
+StepKinematics_KinematicPropertyMechanismRepresentation.hxx
+StepKinematics_KinematicTopologyStructure.cxx
+StepKinematics_KinematicTopologyStructure.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_OrientedJoint.cxx
+StepKinematics_OrientedJoint.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_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_SuParameters.cxx
+StepKinematics_SuParameters.hxx
+StepKinematics_SurfacePair.cxx
+StepKinematics_SurfacePair.hxx
+StepKinematics_SurfacePairWithRange.cxx
+StepKinematics_SurfacePairWithRange.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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 ()
+{
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_CylindricalPairValue, StepKinematics_PairValue)
+
+};
+#endif // _StepKinematics_CylindricalPairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 ()
+{
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_GearPairValue, StepKinematics_PairValue)
+
+};
+#endif // _StepKinematics_GearPairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 ()
+{
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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>
+
+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();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_KinematicLinkRepresentation, StepRepr_Representation)
+
+};
+#endif // _StepKinematics_KinematicLinkRepresentation_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 ()
+{
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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>
+
+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();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_KinematicPropertyMechanismRepresentation, StepKinematics_KinematicPropertyDefinitionRepresentation)
+
+};
+#endif // _StepKinematics_KinematicPropertyMechanismRepresentation_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 ()
+{
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_LowOrderKinematicPairValue, StepKinematics_PairValue)
+
+};
+#endif // _StepKinematics_LowOrderKinematicPairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 ()
+{
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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>
+
+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();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_MechanismRepresentation, StepRepr_Representation)
+
+};
+#endif // _StepKinematics_MechanismRepresentation_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 ()
+{
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_PlanarPairValue, StepKinematics_PairValue)
+
+};
+#endif // _StepKinematics_PlanarPairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 ()
+{
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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>
+
+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();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_PointOnPlanarCurvePairValue, StepKinematics_PairValue)
+
+};
+#endif // _StepKinematics_PointOnPlanarCurvePairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 ()
+{
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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>
+
+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();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_PointOnSurfacePairValue, StepKinematics_PairValue)
+
+};
+#endif // _StepKinematics_PointOnSurfacePairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 ()
+{
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_PrismaticPairValue, StepKinematics_PairValue)
+
+};
+#endif // _StepKinematics_PrismaticPairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 ()
+{
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_RackAndPinionPairValue, StepKinematics_PairValue)
+
+};
+#endif // _StepKinematics_RackAndPinionPairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 ()
+{
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_RevolutePairValue, StepKinematics_PairValue)
+
+};
+#endif // _StepKinematics_RevolutePairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 <StepKinematics_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(StepKinematics_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(StepKinematics_SuParameters) StepKinematics_RigidPlacement::SuParameters () const
+{
+ return Handle(StepKinematics_SuParameters)::DownCast(Value());
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 StepKinematics_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(StepKinematics_SuParameters) SuParameters() const;
+
+};
+#endif // _StepKinematics_RigidPlacement_HeaderFile
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 ()
+{
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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>
+
+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();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_RollingCurvePairValue, StepKinematics_PairValue)
+
+};
+#endif // _StepKinematics_RollingCurvePairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 ()
+{
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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>
+
+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();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_RollingSurfacePairValue, StepKinematics_PairValue)
+
+};
+#endif // _StepKinematics_RollingSurfacePairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 ()
+{
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_ScrewPairValue, StepKinematics_PairValue)
+
+};
+#endif // _StepKinematics_ScrewPairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 ()
+{
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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>
+
+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();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_SlidingCurvePairValue, StepKinematics_PairValue)
+
+};
+#endif // _StepKinematics_SlidingCurvePairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 ()
+{
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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>
+
+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();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_SlidingSurfacePairValue, StepKinematics_PairValue)
+
+};
+#endif // _StepKinematics_SlidingSurfacePairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 ()
+{
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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>
+
+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();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_SphericalPairValue, StepKinematics_PairValue)
+
+};
+#endif // _StepKinematics_SphericalPairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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_SuParameters.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_SuParameters, StepGeom_GeometricRepresentationItem)
+
+//=======================================================================
+//function : StepKinematics_SuParameters
+//purpose :
+//=======================================================================
+
+StepKinematics_SuParameters::StepKinematics_SuParameters ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepKinematics_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 StepKinematics_SuParameters::A () const
+{
+ return myA;
+}
+
+//=======================================================================
+//function : SetA
+//purpose :
+//=======================================================================
+
+void StepKinematics_SuParameters::SetA (const Standard_Real theA)
+{
+ myA = theA;
+}
+
+//=======================================================================
+//function : Alpha
+//purpose :
+//=======================================================================
+
+Standard_Real StepKinematics_SuParameters::Alpha () const
+{
+ return myAlpha;
+}
+
+//=======================================================================
+//function : SetAlpha
+//purpose :
+//=======================================================================
+
+void StepKinematics_SuParameters::SetAlpha (const Standard_Real theAlpha)
+{
+ myAlpha = theAlpha;
+}
+
+//=======================================================================
+//function : B
+//purpose :
+//=======================================================================
+
+Standard_Real StepKinematics_SuParameters::B () const
+{
+ return myB;
+}
+
+//=======================================================================
+//function : SetB
+//purpose :
+//=======================================================================
+
+void StepKinematics_SuParameters::SetB (const Standard_Real theB)
+{
+ myB = theB;
+}
+
+//=======================================================================
+//function : Beta
+//purpose :
+//=======================================================================
+
+Standard_Real StepKinematics_SuParameters::Beta () const
+{
+ return myBeta;
+}
+
+//=======================================================================
+//function : SetBeta
+//purpose :
+//=======================================================================
+
+void StepKinematics_SuParameters::SetBeta (const Standard_Real theBeta)
+{
+ myBeta = theBeta;
+}
+
+//=======================================================================
+//function : C
+//purpose :
+//=======================================================================
+
+Standard_Real StepKinematics_SuParameters::C () const
+{
+ return myC;
+}
+
+//=======================================================================
+//function : SetC
+//purpose :
+//=======================================================================
+
+void StepKinematics_SuParameters::SetC (const Standard_Real theC)
+{
+ myC = theC;
+}
+
+//=======================================================================
+//function : Gamma
+//purpose :
+//=======================================================================
+
+Standard_Real StepKinematics_SuParameters::Gamma () const
+{
+ return myGamma;
+}
+
+//=======================================================================
+//function : SetGamma
+//purpose :
+//=======================================================================
+
+void StepKinematics_SuParameters::SetGamma (const Standard_Real theGamma)
+{
+ myGamma = theGamma;
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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_SuParameters_HeaderFile_
+#define _StepKinematics_SuParameters_HeaderFile_
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepGeom_GeometricRepresentationItem.hxx>
+
+#include <TCollection_HAsciiString.hxx>
+
+DEFINE_STANDARD_HANDLE(StepKinematics_SuParameters, StepGeom_GeometricRepresentationItem)
+
+//! Representation of STEP entity SuParameters
+class StepKinematics_SuParameters : public StepGeom_GeometricRepresentationItem
+{
+public :
+
+ //! default constructor
+ Standard_EXPORT StepKinematics_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(StepKinematics_SuParameters, StepGeom_GeometricRepresentationItem)
+
+private:
+ Standard_Real myA;
+ Standard_Real myAlpha;
+ Standard_Real myB;
+ Standard_Real myBeta;
+ Standard_Real myC;
+ Standard_Real myGamma;
+
+};
+#endif // _StepKinematics_SuParameters_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 ()
+{
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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>
+
+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();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_UnconstrainedPairValue, StepKinematics_PairValue)
+
+};
+#endif // _StepKinematics_UnconstrainedPairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 ()
+{
+}
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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();
+
+DEFINE_STANDARD_RTTIEXT(StepKinematics_UniversalPairValue, StepKinematics_PairValue)
+
+};
+#endif // _StepKinematics_UniversalPairValue_HeaderFile_
--- /dev/null
+// Created on : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:03 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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_EXPORT Standard_Boolean HasDescription()
+ {
+ return !theDescription.IsNull();
+ }
Standard_EXPORT void SetDescription (const Handle(TCollection_HAsciiString)& aDescription);
--- /dev/null
+// Created on : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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 : Mon Apr 13 15:22:02 2020
+// Created by: Irina KRYLOVA
+// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
+// Copyright (c) Open CASCADE 2020
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of 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_EXPORT Standard_Boolean HasDescription()
+ {
+ return !description.IsNull();
+ }
Standard_EXPORT void SetDescription (const Handle(TCollection_HAsciiString)& aDescription);
RWStepVisual
StepDimTol
RWStepDimTol
+StepKinematics
+RWStepKinematics
projects / occt-copy.git / commitdiff