From: ika Date: Tue, 7 Apr 2020 10:15:44 +0000 (+0300) Subject: Add new STEP entities X-Git-Url: http://git.dev.opencascade.org/gitweb/?a=commitdiff_plain;h=70ab5a7f70993aedb792ddf5cb8183ddb248e1b9;p=occt-copy.git Add new STEP entities --- diff --git a/src/RWStepAP214/RWStepAP214_GeneralModule.cxx b/src/RWStepAP214/RWStepAP214_GeneralModule.cxx index 05081cb5ad..991fbd9e8d 100644 --- a/src/RWStepAP214/RWStepAP214_GeneralModule.cxx +++ b/src/RWStepAP214/RWStepAP214_GeneralModule.cxx @@ -1357,6 +1357,144 @@ IMPLEMENT_STANDARD_RTTIEXT(RWStepAP214_GeneralModule,StepData_GeneralModule) #include #include #include +// Added for kinematics implementation +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include static Standard_Integer catsh,catdr,catstr,catdsc,cataux; @@ -5155,7 +5293,484 @@ void RWStepAP214_GeneralModule::FillSharedCase(const Standard_Integer CN, 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; } @@ -7169,6 +7784,210 @@ Standard_Boolean RWStepAP214_GeneralModule::NewVoid 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: @@ -7769,6 +8588,75 @@ Standard_Integer RWStepAP214_GeneralModule::CategoryNumber 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; } diff --git a/src/RWStepAP214/RWStepAP214_ReadWriteModule.cxx b/src/RWStepAP214/RWStepAP214_ReadWriteModule.cxx index 3f1af6de27..be5ee61296 100644 --- a/src/RWStepAP214/RWStepAP214_ReadWriteModule.cxx +++ b/src/RWStepAP214/RWStepAP214_ReadWriteModule.cxx @@ -1404,6 +1404,143 @@ IMPLEMENT_STANDARD_RTTIEXT(RWStepAP214_ReadWriteModule,StepData_ReadWriteModule) #include #include #include +// Added for kinematics implementation +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // -- General Declarations (Recognize, StepType) --- @@ -2046,6 +2183,76 @@ static TCollection_AsciiString Reco_CharacterizedRepresentation("CHARACTERIZED_R 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 typenums; @@ -2703,6 +2910,76 @@ RWStepAP214_ReadWriteModule::RWStepAP214_ReadWriteModule () 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 @@ -4558,6 +4835,76 @@ const TCollection_AsciiString& RWStepAP214_ReadWriteModule::StepType 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; } } @@ -9457,6 +9804,483 @@ void RWStepAP214_ReadWriteModule::ReadStep(const Standard_Integer CN, 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: @@ -14314,6 +15138,483 @@ void RWStepAP214_ReadWriteModule::WriteStep(const Standard_Integer CN, 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; diff --git a/src/RWStepKinematics/FILES b/src/RWStepKinematics/FILES new file mode 100644 index 0000000000..66edd25fc0 --- /dev/null +++ b/src/RWStepKinematics/FILES @@ -0,0 +1,132 @@ +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 diff --git a/src/RWStepKinematics/RWStepKinematics_RWActuatedKinematicPair.cxx b/src/RWStepKinematics/RWStepKinematics_RWActuatedKinematicPair.cxx new file mode 100644 index 0000000000..7c40bd368b --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWActuatedKinematicPair.cxx @@ -0,0 +1,321 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWActuatedKinematicPair.hxx b/src/RWStepKinematics/RWStepKinematics_RWActuatedKinematicPair.hxx new file mode 100644 index 0000000000..094b2aa007 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWActuatedKinematicPair.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWContextDependentKinematicLinkRepresentation.cxx b/src/RWStepKinematics/RWStepKinematics_RWContextDependentKinematicLinkRepresentation.cxx new file mode 100644 index 0000000000..c89cbbe958 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWContextDependentKinematicLinkRepresentation.cxx @@ -0,0 +1,89 @@ +// 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 +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWContextDependentKinematicLinkRepresentation.hxx b/src/RWStepKinematics/RWStepKinematics_RWContextDependentKinematicLinkRepresentation.hxx new file mode 100644 index 0000000000..a2af3f4502 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWContextDependentKinematicLinkRepresentation.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWCylindricalPair.cxx b/src/RWStepKinematics/RWStepKinematics_RWCylindricalPair.cxx new file mode 100644 index 0000000000..a8e1c05d8e --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWCylindricalPair.cxx @@ -0,0 +1,183 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWCylindricalPair.hxx b/src/RWStepKinematics/RWStepKinematics_RWCylindricalPair.hxx new file mode 100644 index 0000000000..8fa4d98d84 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWCylindricalPair.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWCylindricalPairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWCylindricalPairValue.cxx new file mode 100644 index 0000000000..9b45a6f599 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWCylindricalPairValue.cxx @@ -0,0 +1,93 @@ +// 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 +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWCylindricalPairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWCylindricalPairValue.hxx new file mode 100644 index 0000000000..4e13c67f12 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWCylindricalPairValue.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWCylindricalPairWithRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWCylindricalPairWithRange.cxx new file mode 100644 index 0000000000..80df508328 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWCylindricalPairWithRange.cxx @@ -0,0 +1,258 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWCylindricalPairWithRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWCylindricalPairWithRange.hxx new file mode 100644 index 0000000000..bd9afa7bde --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWCylindricalPairWithRange.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWFullyConstrainedPair.cxx b/src/RWStepKinematics/RWStepKinematics_RWFullyConstrainedPair.cxx new file mode 100644 index 0000000000..6a9e6e9489 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWFullyConstrainedPair.cxx @@ -0,0 +1,183 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWFullyConstrainedPair.hxx b/src/RWStepKinematics/RWStepKinematics_RWFullyConstrainedPair.hxx new file mode 100644 index 0000000000..220c63c802 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWFullyConstrainedPair.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWGearPair.cxx b/src/RWStepKinematics/RWStepKinematics_RWGearPair.cxx new file mode 100644 index 0000000000..3925be295e --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWGearPair.cxx @@ -0,0 +1,177 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWGearPair.hxx b/src/RWStepKinematics/RWStepKinematics_RWGearPair.hxx new file mode 100644 index 0000000000..6d99d816bd --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWGearPair.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWGearPairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWGearPairValue.cxx new file mode 100644 index 0000000000..83613770d2 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWGearPairValue.cxx @@ -0,0 +1,93 @@ +// 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 +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWGearPairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWGearPairValue.hxx new file mode 100644 index 0000000000..9311b9720e --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWGearPairValue.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWGearPairWithRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWGearPairWithRange.cxx new file mode 100644 index 0000000000..4ef689d6d1 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWGearPairWithRange.cxx @@ -0,0 +1,217 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWGearPairWithRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWGearPairWithRange.hxx new file mode 100644 index 0000000000..eca980cd99 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWGearPairWithRange.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWHomokineticPair.cxx b/src/RWStepKinematics/RWStepKinematics_RWHomokineticPair.cxx new file mode 100644 index 0000000000..4908d88cd3 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWHomokineticPair.cxx @@ -0,0 +1,207 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWHomokineticPair.hxx b/src/RWStepKinematics/RWStepKinematics_RWHomokineticPair.hxx new file mode 100644 index 0000000000..f0b62e133e --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWHomokineticPair.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWKinematicJoint.cxx b/src/RWStepKinematics/RWStepKinematics_RWKinematicJoint.cxx new file mode 100644 index 0000000000..242b6a25ec --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWKinematicJoint.cxx @@ -0,0 +1,101 @@ +// 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 +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWKinematicJoint.hxx b/src/RWStepKinematics/RWStepKinematics_RWKinematicJoint.hxx new file mode 100644 index 0000000000..92159ae04f --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWKinematicJoint.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWKinematicLink.cxx b/src/RWStepKinematics/RWStepKinematics_RWKinematicLink.cxx new file mode 100644 index 0000000000..677a250d67 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWKinematicLink.cxx @@ -0,0 +1,78 @@ +// 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 +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWKinematicLink.hxx b/src/RWStepKinematics/RWStepKinematics_RWKinematicLink.hxx new file mode 100644 index 0000000000..1ce5064fb7 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWKinematicLink.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWKinematicLinkRepresentationAssociation.cxx b/src/RWStepKinematics/RWStepKinematics_RWKinematicLinkRepresentationAssociation.cxx new file mode 100644 index 0000000000..ad2fd23d5c --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWKinematicLinkRepresentationAssociation.cxx @@ -0,0 +1,118 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWKinematicLinkRepresentationAssociation.hxx b/src/RWStepKinematics/RWStepKinematics_RWKinematicLinkRepresentationAssociation.hxx new file mode 100644 index 0000000000..639d994cf3 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWKinematicLinkRepresentationAssociation.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWKinematicPropertyMechanismRepresentation.cxx b/src/RWStepKinematics/RWStepKinematics_RWKinematicPropertyMechanismRepresentation.cxx new file mode 100644 index 0000000000..03d24d4e56 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWKinematicPropertyMechanismRepresentation.cxx @@ -0,0 +1,89 @@ +// 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 +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWKinematicPropertyMechanismRepresentation.hxx b/src/RWStepKinematics/RWStepKinematics_RWKinematicPropertyMechanismRepresentation.hxx new file mode 100644 index 0000000000..e1e0da4af7 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWKinematicPropertyMechanismRepresentation.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyStructure.cxx b/src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyStructure.cxx new file mode 100644 index 0000000000..2eb1dde644 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyStructure.cxx @@ -0,0 +1,115 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyStructure.hxx b/src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyStructure.hxx new file mode 100644 index 0000000000..4accd44c22 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyStructure.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPair.cxx b/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPair.cxx new file mode 100644 index 0000000000..8b64f57618 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPair.cxx @@ -0,0 +1,183 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPair.hxx b/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPair.hxx new file mode 100644 index 0000000000..bbd21af8dd --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPair.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPairValue.cxx new file mode 100644 index 0000000000..b978ae4feb --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPairValue.cxx @@ -0,0 +1,93 @@ +// 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 +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPairValue.hxx new file mode 100644 index 0000000000..9a7b3bbeee --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPairValue.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPairWithRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPairWithRange.cxx new file mode 100644 index 0000000000..fbb4bc25e9 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPairWithRange.cxx @@ -0,0 +1,394 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPairWithRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPairWithRange.hxx new file mode 100644 index 0000000000..78260a811a --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPairWithRange.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWMechanismRepresentation.cxx b/src/RWStepKinematics/RWStepKinematics_RWMechanismRepresentation.cxx new file mode 100644 index 0000000000..cafee74810 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWMechanismRepresentation.cxx @@ -0,0 +1,115 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWMechanismRepresentation.hxx b/src/RWStepKinematics/RWStepKinematics_RWMechanismRepresentation.hxx new file mode 100644 index 0000000000..c3b002474c --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWMechanismRepresentation.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWOrientedJoint.cxx b/src/RWStepKinematics/RWStepKinematics_RWOrientedJoint.cxx new file mode 100644 index 0000000000..87ee0ac2b5 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWOrientedJoint.cxx @@ -0,0 +1,121 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWOrientedJoint.hxx b/src/RWStepKinematics/RWStepKinematics_RWOrientedJoint.hxx new file mode 100644 index 0000000000..005d87207b --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWOrientedJoint.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPlanarCurvePair.cxx b/src/RWStepKinematics/RWStepKinematics_RWPlanarCurvePair.cxx new file mode 100644 index 0000000000..2a44a53db4 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPlanarCurvePair.cxx @@ -0,0 +1,170 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPlanarCurvePair.hxx b/src/RWStepKinematics/RWStepKinematics_RWPlanarCurvePair.hxx new file mode 100644 index 0000000000..5cc7aae29c --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPlanarCurvePair.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPlanarCurvePairRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWPlanarCurvePairRange.cxx new file mode 100644 index 0000000000..57f256009f --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPlanarCurvePairRange.cxx @@ -0,0 +1,193 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPlanarCurvePairRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWPlanarCurvePairRange.hxx new file mode 100644 index 0000000000..2c351672d9 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPlanarCurvePairRange.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPlanarPair.cxx b/src/RWStepKinematics/RWStepKinematics_RWPlanarPair.cxx new file mode 100644 index 0000000000..837f368ed7 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPlanarPair.cxx @@ -0,0 +1,183 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPlanarPair.hxx b/src/RWStepKinematics/RWStepKinematics_RWPlanarPair.hxx new file mode 100644 index 0000000000..7f00440b78 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPlanarPair.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPlanarPairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWPlanarPairValue.cxx new file mode 100644 index 0000000000..af66fe44ae --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPlanarPairValue.cxx @@ -0,0 +1,93 @@ +// 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 +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPlanarPairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWPlanarPairValue.hxx new file mode 100644 index 0000000000..87e15d8609 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPlanarPairValue.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPlanarPairWithRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWPlanarPairWithRange.cxx new file mode 100644 index 0000000000..45fdfe2003 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPlanarPairWithRange.cxx @@ -0,0 +1,292 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPlanarPairWithRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWPlanarPairWithRange.hxx new file mode 100644 index 0000000000..cd8c682301 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPlanarPairWithRange.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePair.cxx b/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePair.cxx new file mode 100644 index 0000000000..82fc13fa9f --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePair.cxx @@ -0,0 +1,162 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePair.hxx b/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePair.hxx new file mode 100644 index 0000000000..abaae96c22 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePair.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePairValue.cxx new file mode 100644 index 0000000000..0236097bd3 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePairValue.cxx @@ -0,0 +1,93 @@ +// 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 +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePairValue.hxx new file mode 100644 index 0000000000..e5f95cb0be --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePairValue.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePairWithRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePairWithRange.cxx new file mode 100644 index 0000000000..1274b30953 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePairWithRange.cxx @@ -0,0 +1,280 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePairWithRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePairWithRange.hxx new file mode 100644 index 0000000000..19ab222711 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePairWithRange.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePair.cxx b/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePair.cxx new file mode 100644 index 0000000000..95df7eac99 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePair.cxx @@ -0,0 +1,155 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePair.hxx b/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePair.hxx new file mode 100644 index 0000000000..1f8509368c --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePair.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePairValue.cxx new file mode 100644 index 0000000000..28316d14be --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePairValue.cxx @@ -0,0 +1,93 @@ +// 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 +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePairValue.hxx new file mode 100644 index 0000000000..31f51fe691 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePairValue.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePairWithRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePairWithRange.cxx new file mode 100644 index 0000000000..1fcacdec70 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePairWithRange.cxx @@ -0,0 +1,273 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePairWithRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePairWithRange.hxx new file mode 100644 index 0000000000..29fd2b5615 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePairWithRange.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPrismaticPair.cxx b/src/RWStepKinematics/RWStepKinematics_RWPrismaticPair.cxx new file mode 100644 index 0000000000..47aa9f5cb6 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPrismaticPair.cxx @@ -0,0 +1,183 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPrismaticPair.hxx b/src/RWStepKinematics/RWStepKinematics_RWPrismaticPair.hxx new file mode 100644 index 0000000000..dbfdb0ef7b --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPrismaticPair.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPrismaticPairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWPrismaticPairValue.cxx new file mode 100644 index 0000000000..ee7fb68dab --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPrismaticPairValue.cxx @@ -0,0 +1,93 @@ +// 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 +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPrismaticPairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWPrismaticPairValue.hxx new file mode 100644 index 0000000000..e113e69279 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPrismaticPairValue.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPrismaticPairWithRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWPrismaticPairWithRange.cxx new file mode 100644 index 0000000000..20aa21d20f --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPrismaticPairWithRange.cxx @@ -0,0 +1,224 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPrismaticPairWithRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWPrismaticPairWithRange.hxx new file mode 100644 index 0000000000..45e2293e67 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPrismaticPairWithRange.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWProductDefinitionKinematics.cxx b/src/RWStepKinematics/RWStepKinematics_RWProductDefinitionKinematics.cxx new file mode 100644 index 0000000000..cd880367df --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWProductDefinitionKinematics.cxx @@ -0,0 +1,104 @@ +// 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 +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWProductDefinitionKinematics.hxx b/src/RWStepKinematics/RWStepKinematics_RWProductDefinitionKinematics.hxx new file mode 100644 index 0000000000..590936b020 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWProductDefinitionKinematics.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWProductDefinitionRelationshipKinematics.cxx b/src/RWStepKinematics/RWStepKinematics_RWProductDefinitionRelationshipKinematics.cxx new file mode 100644 index 0000000000..8f8b67c9bf --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWProductDefinitionRelationshipKinematics.cxx @@ -0,0 +1,104 @@ +// 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 +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWProductDefinitionRelationshipKinematics.hxx b/src/RWStepKinematics/RWStepKinematics_RWProductDefinitionRelationshipKinematics.hxx new file mode 100644 index 0000000000..2cc6c1ebb9 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWProductDefinitionRelationshipKinematics.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPair.cxx b/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPair.cxx new file mode 100644 index 0000000000..0fb8270c3e --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPair.cxx @@ -0,0 +1,153 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPair.hxx b/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPair.hxx new file mode 100644 index 0000000000..c83499bc1f --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPair.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPairValue.cxx new file mode 100644 index 0000000000..e9df3e31df --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPairValue.cxx @@ -0,0 +1,93 @@ +// 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 +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPairValue.hxx new file mode 100644 index 0000000000..bfaaf2cfae --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPairValue.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPairWithRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPairWithRange.cxx new file mode 100644 index 0000000000..8f93b68c08 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPairWithRange.cxx @@ -0,0 +1,193 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPairWithRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPairWithRange.hxx new file mode 100644 index 0000000000..2bd103a095 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPairWithRange.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWRevolutePair.cxx b/src/RWStepKinematics/RWStepKinematics_RWRevolutePair.cxx new file mode 100644 index 0000000000..acdb1d7055 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRevolutePair.cxx @@ -0,0 +1,183 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWRevolutePair.hxx b/src/RWStepKinematics/RWStepKinematics_RWRevolutePair.hxx new file mode 100644 index 0000000000..2b6d6501e1 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRevolutePair.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWRevolutePairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWRevolutePairValue.cxx new file mode 100644 index 0000000000..4e39e3fbb6 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRevolutePairValue.cxx @@ -0,0 +1,93 @@ +// 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 +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWRevolutePairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWRevolutePairValue.hxx new file mode 100644 index 0000000000..267bffdf1b --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRevolutePairValue.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWRevolutePairWithRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWRevolutePairWithRange.cxx new file mode 100644 index 0000000000..8718cb7f6a --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRevolutePairWithRange.cxx @@ -0,0 +1,224 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWRevolutePairWithRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWRevolutePairWithRange.hxx new file mode 100644 index 0000000000..afe8705102 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRevolutePairWithRange.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWRollingCurvePair.cxx b/src/RWStepKinematics/RWStepKinematics_RWRollingCurvePair.cxx new file mode 100644 index 0000000000..44c9fc4cb9 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRollingCurvePair.cxx @@ -0,0 +1,170 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWRollingCurvePair.hxx b/src/RWStepKinematics/RWStepKinematics_RWRollingCurvePair.hxx new file mode 100644 index 0000000000..43a5cac4cc --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRollingCurvePair.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWRollingCurvePairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWRollingCurvePairValue.cxx new file mode 100644 index 0000000000..b70d8e9194 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRollingCurvePairValue.cxx @@ -0,0 +1,93 @@ +// 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 +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWRollingCurvePairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWRollingCurvePairValue.hxx new file mode 100644 index 0000000000..652de6946f --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRollingCurvePairValue.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWRollingSurfacePair.cxx b/src/RWStepKinematics/RWStepKinematics_RWRollingSurfacePair.cxx new file mode 100644 index 0000000000..eef0be27ad --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRollingSurfacePair.cxx @@ -0,0 +1,170 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWRollingSurfacePair.hxx b/src/RWStepKinematics/RWStepKinematics_RWRollingSurfacePair.hxx new file mode 100644 index 0000000000..f67d883f4e --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRollingSurfacePair.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWRollingSurfacePairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWRollingSurfacePairValue.cxx new file mode 100644 index 0000000000..8e07fde345 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRollingSurfacePairValue.cxx @@ -0,0 +1,93 @@ +// 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 +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWRollingSurfacePairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWRollingSurfacePairValue.hxx new file mode 100644 index 0000000000..4ff4a12958 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRollingSurfacePairValue.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWRotationAboutDirection.cxx b/src/RWStepKinematics/RWStepKinematics_RWRotationAboutDirection.cxx new file mode 100644 index 0000000000..dadd5867cc --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRotationAboutDirection.cxx @@ -0,0 +1,100 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWRotationAboutDirection.hxx b/src/RWStepKinematics/RWStepKinematics_RWRotationAboutDirection.hxx new file mode 100644 index 0000000000..a0c17eba26 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRotationAboutDirection.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWScrewPair.cxx b/src/RWStepKinematics/RWStepKinematics_RWScrewPair.cxx new file mode 100644 index 0000000000..2fc0631a1d --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWScrewPair.cxx @@ -0,0 +1,153 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWScrewPair.hxx b/src/RWStepKinematics/RWStepKinematics_RWScrewPair.hxx new file mode 100644 index 0000000000..333d10d51d --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWScrewPair.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWScrewPairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWScrewPairValue.cxx new file mode 100644 index 0000000000..46618fe215 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWScrewPairValue.cxx @@ -0,0 +1,93 @@ +// 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 +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWScrewPairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWScrewPairValue.hxx new file mode 100644 index 0000000000..e1ecfb5e75 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWScrewPairValue.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWScrewPairWithRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWScrewPairWithRange.cxx new file mode 100644 index 0000000000..c6f78ef6e3 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWScrewPairWithRange.cxx @@ -0,0 +1,193 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWScrewPairWithRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWScrewPairWithRange.hxx new file mode 100644 index 0000000000..67d07bd95c --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWScrewPairWithRange.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWSlidingCurvePair.cxx b/src/RWStepKinematics/RWStepKinematics_RWSlidingCurvePair.cxx new file mode 100644 index 0000000000..796c211c8f --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSlidingCurvePair.cxx @@ -0,0 +1,170 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWSlidingCurvePair.hxx b/src/RWStepKinematics/RWStepKinematics_RWSlidingCurvePair.hxx new file mode 100644 index 0000000000..3cd921da79 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSlidingCurvePair.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWSlidingCurvePairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWSlidingCurvePairValue.cxx new file mode 100644 index 0000000000..7f3e704917 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSlidingCurvePairValue.cxx @@ -0,0 +1,93 @@ +// 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 +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWSlidingCurvePairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWSlidingCurvePairValue.hxx new file mode 100644 index 0000000000..0f01ee439e --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSlidingCurvePairValue.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWSlidingSurfacePair.cxx b/src/RWStepKinematics/RWStepKinematics_RWSlidingSurfacePair.cxx new file mode 100644 index 0000000000..e35583a6ef --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSlidingSurfacePair.cxx @@ -0,0 +1,170 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWSlidingSurfacePair.hxx b/src/RWStepKinematics/RWStepKinematics_RWSlidingSurfacePair.hxx new file mode 100644 index 0000000000..db24b46cd2 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSlidingSurfacePair.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWSlidingSurfacePairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWSlidingSurfacePairValue.cxx new file mode 100644 index 0000000000..460c7f7104 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSlidingSurfacePairValue.cxx @@ -0,0 +1,93 @@ +// 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 +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWSlidingSurfacePairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWSlidingSurfacePairValue.hxx new file mode 100644 index 0000000000..900a5eedad --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSlidingSurfacePairValue.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWSphericalPair.cxx b/src/RWStepKinematics/RWStepKinematics_RWSphericalPair.cxx new file mode 100644 index 0000000000..8fda94d3df --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSphericalPair.cxx @@ -0,0 +1,183 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWSphericalPair.hxx b/src/RWStepKinematics/RWStepKinematics_RWSphericalPair.hxx new file mode 100644 index 0000000000..e87af4cdc5 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSphericalPair.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWSphericalPairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairValue.cxx new file mode 100644 index 0000000000..9bfe6dc719 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairValue.cxx @@ -0,0 +1,93 @@ +// 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 +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWSphericalPairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairValue.hxx new file mode 100644 index 0000000000..f003e1917e --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairValue.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithPin.cxx b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithPin.cxx new file mode 100644 index 0000000000..c38caaaa86 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithPin.cxx @@ -0,0 +1,183 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithPin.hxx b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithPin.hxx new file mode 100644 index 0000000000..0e3df937ee --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithPin.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithPinAndRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithPinAndRange.cxx new file mode 100644 index 0000000000..c2ea5c9efb --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithPinAndRange.cxx @@ -0,0 +1,258 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithPinAndRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithPinAndRange.hxx new file mode 100644 index 0000000000..b6407f1c66 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithPinAndRange.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithRange.cxx new file mode 100644 index 0000000000..a8581e7205 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithRange.cxx @@ -0,0 +1,292 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithRange.hxx new file mode 100644 index 0000000000..5f8eba1922 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithRange.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWSuParameters.cxx b/src/RWStepKinematics/RWStepKinematics_RWSuParameters.cxx new file mode 100644 index 0000000000..2bc9f6ef57 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSuParameters.cxx @@ -0,0 +1,121 @@ +// 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 +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWSuParameters.hxx b/src/RWStepKinematics/RWStepKinematics_RWSuParameters.hxx new file mode 100644 index 0000000000..235bc4fb5f --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSuParameters.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWSurfacePairWithRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWSurfacePairWithRange.cxx new file mode 100644 index 0000000000..37807ee2bc --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSurfacePairWithRange.cxx @@ -0,0 +1,228 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWSurfacePairWithRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWSurfacePairWithRange.hxx new file mode 100644 index 0000000000..8f6041af93 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSurfacePairWithRange.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWUnconstrainedPair.cxx b/src/RWStepKinematics/RWStepKinematics_RWUnconstrainedPair.cxx new file mode 100644 index 0000000000..7038ea4509 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWUnconstrainedPair.cxx @@ -0,0 +1,183 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWUnconstrainedPair.hxx b/src/RWStepKinematics/RWStepKinematics_RWUnconstrainedPair.hxx new file mode 100644 index 0000000000..6cda33ce28 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWUnconstrainedPair.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWUnconstrainedPairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWUnconstrainedPairValue.cxx new file mode 100644 index 0000000000..ff8e1cd658 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWUnconstrainedPairValue.cxx @@ -0,0 +1,93 @@ +// 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 +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWUnconstrainedPairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWUnconstrainedPairValue.hxx new file mode 100644 index 0000000000..34c9229cb0 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWUnconstrainedPairValue.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWUniversalPair.cxx b/src/RWStepKinematics/RWStepKinematics_RWUniversalPair.cxx new file mode 100644 index 0000000000..d1d4d11c5b --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWUniversalPair.cxx @@ -0,0 +1,207 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWUniversalPair.hxx b/src/RWStepKinematics/RWStepKinematics_RWUniversalPair.hxx new file mode 100644 index 0000000000..da8ea8ad85 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWUniversalPair.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWUniversalPairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWUniversalPairValue.cxx new file mode 100644 index 0000000000..b61d479b16 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWUniversalPairValue.cxx @@ -0,0 +1,93 @@ +// 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 +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWUniversalPairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWUniversalPairValue.hxx new file mode 100644 index 0000000000..e6ef6ec0ff --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWUniversalPairValue.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWUniversalPairWithRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWUniversalPairWithRange.cxx new file mode 100644 index 0000000000..3d8f5c607e --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWUniversalPairWithRange.cxx @@ -0,0 +1,281 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWUniversalPairWithRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWUniversalPairWithRange.hxx new file mode 100644 index 0000000000..cacad09652 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWUniversalPairWithRange.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepRepr/FILES b/src/RWStepRepr/FILES index e1dc12da99..3dab652854 100644 --- a/src/RWStepRepr/FILES +++ b/src/RWStepRepr/FILES @@ -92,10 +92,14 @@ RWStepRepr_RWRepresentation.cxx 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 diff --git a/src/RWStepRepr/RWStepRepr_RWRepresentationContextReference.cxx b/src/RWStepRepr/RWStepRepr_RWRepresentationContextReference.cxx new file mode 100644 index 0000000000..9b82a0f384 --- /dev/null +++ b/src/RWStepRepr/RWStepRepr_RWRepresentationContextReference.cxx @@ -0,0 +1,78 @@ +// 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 +#include +#include +#include +#include +#include + +//======================================================================= +//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 +} diff --git a/src/RWStepRepr/RWStepRepr_RWRepresentationContextReference.hxx b/src/RWStepRepr/RWStepRepr_RWRepresentationContextReference.hxx new file mode 100644 index 0000000000..3723869749 --- /dev/null +++ b/src/RWStepRepr/RWStepRepr_RWRepresentationContextReference.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/RWStepRepr/RWStepRepr_RWRepresentationReference.cxx b/src/RWStepRepr/RWStepRepr_RWRepresentationReference.cxx new file mode 100644 index 0000000000..c80d976c8e --- /dev/null +++ b/src/RWStepRepr/RWStepRepr_RWRepresentationReference.cxx @@ -0,0 +1,87 @@ +// 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 +#include +#include +#include +#include +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/RWStepRepr/RWStepRepr_RWRepresentationReference.hxx b/src/RWStepRepr/RWStepRepr_RWRepresentationReference.hxx new file mode 100644 index 0000000000..533c5da742 --- /dev/null +++ b/src/RWStepRepr/RWStepRepr_RWRepresentationReference.hxx @@ -0,0 +1,46 @@ +// 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 +#include +#include + +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_ diff --git a/src/StepAP214/StepAP214_Protocol.cxx b/src/StepAP214/StepAP214_Protocol.cxx index 9d67f7ca2d..0d8ce1ebe4 100644 --- a/src/StepAP214/StepAP214_Protocol.cxx +++ b/src/StepAP214/StepAP214_Protocol.cxx @@ -749,6 +749,76 @@ static Standard_CString schemaAP242DIS = "AP242_MANAGED_MODEL_BASED_3D_ENGINEERI #include #include #include +// Added for kinematics implementation +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + static int THE_StepAP214_Protocol_init = 0; static Interface_DataMapOfTransientInteger types(800); @@ -1459,6 +1529,77 @@ StepAP214_Protocol::StepAP214_Protocol () 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); + } diff --git a/src/StepKinematics/FILES b/src/StepKinematics/FILES new file mode 100644 index 0000000000..fdcfa7c065 --- /dev/null +++ b/src/StepKinematics/FILES @@ -0,0 +1,153 @@ +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 diff --git a/src/StepKinematics/StepKinematics_ActuatedDirection.hxx b/src/StepKinematics/StepKinematics_ActuatedDirection.hxx new file mode 100644 index 0000000000..e37998ed93 --- /dev/null +++ b/src/StepKinematics/StepKinematics_ActuatedDirection.hxx @@ -0,0 +1,27 @@ +// 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 diff --git a/src/StepKinematics/StepKinematics_ActuatedKinematicPair.cxx b/src/StepKinematics/StepKinematics_ActuatedKinematicPair.cxx new file mode 100644 index 0000000000..19734182c0 --- /dev/null +++ b/src/StepKinematics/StepKinematics_ActuatedKinematicPair.cxx @@ -0,0 +1,284 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_ActuatedKinematicPair.hxx b/src/StepKinematics/StepKinematics_ActuatedKinematicPair.hxx new file mode 100644 index 0000000000..597c7c8357 --- /dev/null +++ b/src/StepKinematics/StepKinematics_ActuatedKinematicPair.hxx @@ -0,0 +1,121 @@ +// 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 +#include +#include + +#include +#include +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_ContextDependentKinematicLinkRepresentation.cxx b/src/StepKinematics/StepKinematics_ContextDependentKinematicLinkRepresentation.cxx new file mode 100644 index 0000000000..a9af704f0e --- /dev/null +++ b/src/StepKinematics/StepKinematics_ContextDependentKinematicLinkRepresentation.cxx @@ -0,0 +1,82 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_ContextDependentKinematicLinkRepresentation.hxx b/src/StepKinematics/StepKinematics_ContextDependentKinematicLinkRepresentation.hxx new file mode 100644 index 0000000000..e9fd11e921 --- /dev/null +++ b/src/StepKinematics/StepKinematics_ContextDependentKinematicLinkRepresentation.hxx @@ -0,0 +1,58 @@ +// 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 +#include +#include + +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_CylindricalPair.cxx b/src/StepKinematics/StepKinematics_CylindricalPair.cxx new file mode 100644 index 0000000000..b388b123e1 --- /dev/null +++ b/src/StepKinematics/StepKinematics_CylindricalPair.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_CylindricalPair, StepKinematics_LowOrderKinematicPair) + +//======================================================================= +//function : StepKinematics_CylindricalPair +//purpose : +//======================================================================= + +StepKinematics_CylindricalPair::StepKinematics_CylindricalPair () +{ +} diff --git a/src/StepKinematics/StepKinematics_CylindricalPair.hxx b/src/StepKinematics/StepKinematics_CylindricalPair.hxx new file mode 100644 index 0000000000..5b3ad4d4a2 --- /dev/null +++ b/src/StepKinematics/StepKinematics_CylindricalPair.hxx @@ -0,0 +1,42 @@ +// 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 +#include +#include + +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_CylindricalPairValue.cxx b/src/StepKinematics/StepKinematics_CylindricalPairValue.cxx new file mode 100644 index 0000000000..c00bda8da0 --- /dev/null +++ b/src/StepKinematics/StepKinematics_CylindricalPairValue.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_CylindricalPairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_CylindricalPairValue +//purpose : +//======================================================================= + +StepKinematics_CylindricalPairValue::StepKinematics_CylindricalPairValue () +{ +} diff --git a/src/StepKinematics/StepKinematics_CylindricalPairValue.hxx b/src/StepKinematics/StepKinematics_CylindricalPairValue.hxx new file mode 100644 index 0000000000..5b9e9b9e61 --- /dev/null +++ b/src/StepKinematics/StepKinematics_CylindricalPairValue.hxx @@ -0,0 +1,40 @@ +// 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 +#include +#include + +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_CylindricalPairWithRange.cxx b/src/StepKinematics/StepKinematics_CylindricalPairWithRange.cxx new file mode 100644 index 0000000000..df901ae812 --- /dev/null +++ b/src/StepKinematics/StepKinematics_CylindricalPairWithRange.cxx @@ -0,0 +1,218 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_CylindricalPairWithRange.hxx b/src/StepKinematics/StepKinematics_CylindricalPairWithRange.hxx new file mode 100644 index 0000000000..7c005929ae --- /dev/null +++ b/src/StepKinematics/StepKinematics_CylindricalPairWithRange.hxx @@ -0,0 +1,103 @@ +// 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 +#include +#include + +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_FullyConstrainedPair.cxx b/src/StepKinematics/StepKinematics_FullyConstrainedPair.cxx new file mode 100644 index 0000000000..b1b84b017f --- /dev/null +++ b/src/StepKinematics/StepKinematics_FullyConstrainedPair.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_FullyConstrainedPair, StepKinematics_LowOrderKinematicPair) + +//======================================================================= +//function : StepKinematics_FullyConstrainedPair +//purpose : +//======================================================================= + +StepKinematics_FullyConstrainedPair::StepKinematics_FullyConstrainedPair () +{ +} diff --git a/src/StepKinematics/StepKinematics_FullyConstrainedPair.hxx b/src/StepKinematics/StepKinematics_FullyConstrainedPair.hxx new file mode 100644 index 0000000000..3721196f99 --- /dev/null +++ b/src/StepKinematics/StepKinematics_FullyConstrainedPair.hxx @@ -0,0 +1,42 @@ +// 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 +#include +#include + +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_GearPair.cxx b/src/StepKinematics/StepKinematics_GearPair.cxx new file mode 100644 index 0000000000..7e73744f2d --- /dev/null +++ b/src/StepKinematics/StepKinematics_GearPair.cxx @@ -0,0 +1,165 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_GearPair.hxx b/src/StepKinematics/StepKinematics_GearPair.hxx new file mode 100644 index 0000000000..e79b35f8d2 --- /dev/null +++ b/src/StepKinematics/StepKinematics_GearPair.hxx @@ -0,0 +1,88 @@ +// 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 +#include +#include + +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_GearPairValue.cxx b/src/StepKinematics/StepKinematics_GearPairValue.cxx new file mode 100644 index 0000000000..6a928858ea --- /dev/null +++ b/src/StepKinematics/StepKinematics_GearPairValue.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_GearPairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_GearPairValue +//purpose : +//======================================================================= + +StepKinematics_GearPairValue::StepKinematics_GearPairValue () +{ +} diff --git a/src/StepKinematics/StepKinematics_GearPairValue.hxx b/src/StepKinematics/StepKinematics_GearPairValue.hxx new file mode 100644 index 0000000000..abc0a9e9d9 --- /dev/null +++ b/src/StepKinematics/StepKinematics_GearPairValue.hxx @@ -0,0 +1,40 @@ +// 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 +#include +#include + +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_GearPairWithRange.cxx b/src/StepKinematics/StepKinematics_GearPairWithRange.cxx new file mode 100644 index 0000000000..9868b14fcc --- /dev/null +++ b/src/StepKinematics/StepKinematics_GearPairWithRange.cxx @@ -0,0 +1,138 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_GearPairWithRange.hxx b/src/StepKinematics/StepKinematics_GearPairWithRange.hxx new file mode 100644 index 0000000000..709ae108ef --- /dev/null +++ b/src/StepKinematics/StepKinematics_GearPairWithRange.hxx @@ -0,0 +1,80 @@ +// 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 +#include +#include + +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_HighOrderKinematicPair.cxx b/src/StepKinematics/StepKinematics_HighOrderKinematicPair.cxx new file mode 100644 index 0000000000..60d7e15817 --- /dev/null +++ b/src/StepKinematics/StepKinematics_HighOrderKinematicPair.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_HighOrderKinematicPair, StepKinematics_KinematicPair) + +//======================================================================= +//function : StepKinematics_HighOrderKinematicPair +//purpose : +//======================================================================= + +StepKinematics_HighOrderKinematicPair::StepKinematics_HighOrderKinematicPair () +{ +} diff --git a/src/StepKinematics/StepKinematics_HighOrderKinematicPair.hxx b/src/StepKinematics/StepKinematics_HighOrderKinematicPair.hxx new file mode 100644 index 0000000000..2d39279aef --- /dev/null +++ b/src/StepKinematics/StepKinematics_HighOrderKinematicPair.hxx @@ -0,0 +1,42 @@ +// 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 +#include +#include + +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_HomokineticPair.cxx b/src/StepKinematics/StepKinematics_HomokineticPair.cxx new file mode 100644 index 0000000000..8883262cbd --- /dev/null +++ b/src/StepKinematics/StepKinematics_HomokineticPair.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_HomokineticPair, StepKinematics_UniversalPair) + +//======================================================================= +//function : StepKinematics_HomokineticPair +//purpose : +//======================================================================= + +StepKinematics_HomokineticPair::StepKinematics_HomokineticPair () +{ +} diff --git a/src/StepKinematics/StepKinematics_HomokineticPair.hxx b/src/StepKinematics/StepKinematics_HomokineticPair.hxx new file mode 100644 index 0000000000..6f4cb6ee90 --- /dev/null +++ b/src/StepKinematics/StepKinematics_HomokineticPair.hxx @@ -0,0 +1,42 @@ +// 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 +#include +#include + +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_KinematicJoint.cxx b/src/StepKinematics/StepKinematics_KinematicJoint.cxx new file mode 100644 index 0000000000..6e03775ecd --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicJoint.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_KinematicJoint, StepShape_Edge) + +//======================================================================= +//function : StepKinematics_KinematicJoint +//purpose : +//======================================================================= + +StepKinematics_KinematicJoint::StepKinematics_KinematicJoint () +{ +} diff --git a/src/StepKinematics/StepKinematics_KinematicJoint.hxx b/src/StepKinematics/StepKinematics_KinematicJoint.hxx new file mode 100644 index 0000000000..fdd511ddb7 --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicJoint.hxx @@ -0,0 +1,40 @@ +// 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 +#include +#include + +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_KinematicLink.cxx b/src/StepKinematics/StepKinematics_KinematicLink.cxx new file mode 100644 index 0000000000..129d118f3a --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicLink.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_KinematicLink, StepShape_Vertex) + +//======================================================================= +//function : StepKinematics_KinematicLink +//purpose : +//======================================================================= + +StepKinematics_KinematicLink::StepKinematics_KinematicLink () +{ +} diff --git a/src/StepKinematics/StepKinematics_KinematicLink.hxx b/src/StepKinematics/StepKinematics_KinematicLink.hxx new file mode 100644 index 0000000000..5c855d6e3f --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicLink.hxx @@ -0,0 +1,39 @@ +// 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 +#include +#include + +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_KinematicLinkRepresentation.cxx b/src/StepKinematics/StepKinematics_KinematicLinkRepresentation.cxx new file mode 100644 index 0000000000..570c1bf37c --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicLinkRepresentation.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_KinematicLinkRepresentation, StepRepr_Representation) + +//======================================================================= +//function : StepKinematics_KinematicLinkRepresentation +//purpose : +//======================================================================= + +StepKinematics_KinematicLinkRepresentation::StepKinematics_KinematicLinkRepresentation () +{ +} diff --git a/src/StepKinematics/StepKinematics_KinematicLinkRepresentation.hxx b/src/StepKinematics/StepKinematics_KinematicLinkRepresentation.hxx new file mode 100644 index 0000000000..934fa1d859 --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicLinkRepresentation.hxx @@ -0,0 +1,41 @@ +// 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 +#include +#include + +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_KinematicLinkRepresentationAssociation.cxx b/src/StepKinematics/StepKinematics_KinematicLinkRepresentationAssociation.cxx new file mode 100644 index 0000000000..6c646a4a4f --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicLinkRepresentationAssociation.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_KinematicLinkRepresentationAssociation, StepRepr_RepresentationRelationship) + +//======================================================================= +//function : StepKinematics_KinematicLinkRepresentationAssociation +//purpose : +//======================================================================= + +StepKinematics_KinematicLinkRepresentationAssociation::StepKinematics_KinematicLinkRepresentationAssociation () +{ +} diff --git a/src/StepKinematics/StepKinematics_KinematicLinkRepresentationAssociation.hxx b/src/StepKinematics/StepKinematics_KinematicLinkRepresentationAssociation.hxx new file mode 100644 index 0000000000..c0fbb3b245 --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicLinkRepresentationAssociation.hxx @@ -0,0 +1,40 @@ +// 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 +#include +#include + +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_KinematicPair.cxx b/src/StepKinematics/StepKinematics_KinematicPair.cxx new file mode 100644 index 0000000000..9582b88835 --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicPair.cxx @@ -0,0 +1,92 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_KinematicPair.hxx b/src/StepKinematics/StepKinematics_KinematicPair.hxx new file mode 100644 index 0000000000..5fba8f332e --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicPair.hxx @@ -0,0 +1,65 @@ +// 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 +#include +#include + +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_KinematicPropertyDefinitionRepresentation.cxx b/src/StepKinematics/StepKinematics_KinematicPropertyDefinitionRepresentation.cxx new file mode 100644 index 0000000000..fcbc837711 --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicPropertyDefinitionRepresentation.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_KinematicPropertyDefinitionRepresentation, StepRepr_PropertyDefinitionRepresentation) + +//======================================================================= +//function : StepKinematics_KinematicPropertyDefinitionRepresentation +//purpose : +//======================================================================= + +StepKinematics_KinematicPropertyDefinitionRepresentation::StepKinematics_KinematicPropertyDefinitionRepresentation () +{ +} diff --git a/src/StepKinematics/StepKinematics_KinematicPropertyDefinitionRepresentation.hxx b/src/StepKinematics/StepKinematics_KinematicPropertyDefinitionRepresentation.hxx new file mode 100644 index 0000000000..3bdfb1fd28 --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicPropertyDefinitionRepresentation.hxx @@ -0,0 +1,40 @@ +// 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 +#include +#include + +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_KinematicPropertyMechanismRepresentation.cxx b/src/StepKinematics/StepKinematics_KinematicPropertyMechanismRepresentation.cxx new file mode 100644 index 0000000000..a3517a2a79 --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicPropertyMechanismRepresentation.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_KinematicPropertyMechanismRepresentation, StepKinematics_KinematicPropertyDefinitionRepresentation) + +//======================================================================= +//function : StepKinematics_KinematicPropertyMechanismRepresentation +//purpose : +//======================================================================= + +StepKinematics_KinematicPropertyMechanismRepresentation::StepKinematics_KinematicPropertyMechanismRepresentation () +{ +} diff --git a/src/StepKinematics/StepKinematics_KinematicPropertyMechanismRepresentation.hxx b/src/StepKinematics/StepKinematics_KinematicPropertyMechanismRepresentation.hxx new file mode 100644 index 0000000000..e3638b1689 --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicPropertyMechanismRepresentation.hxx @@ -0,0 +1,40 @@ +// 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 +#include +#include + +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_KinematicTopologyStructure.cxx b/src/StepKinematics/StepKinematics_KinematicTopologyStructure.cxx new file mode 100644 index 0000000000..d533f945fc --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicTopologyStructure.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_KinematicTopologyStructure, StepRepr_Representation) + +//======================================================================= +//function : StepKinematics_KinematicTopologyStructure +//purpose : +//======================================================================= + +StepKinematics_KinematicTopologyStructure::StepKinematics_KinematicTopologyStructure () +{ +} diff --git a/src/StepKinematics/StepKinematics_KinematicTopologyStructure.hxx b/src/StepKinematics/StepKinematics_KinematicTopologyStructure.hxx new file mode 100644 index 0000000000..9300ba6b16 --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicTopologyStructure.hxx @@ -0,0 +1,41 @@ +// 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 +#include +#include + +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_LowOrderKinematicPair.cxx b/src/StepKinematics/StepKinematics_LowOrderKinematicPair.cxx new file mode 100644 index 0000000000..8874b31822 --- /dev/null +++ b/src/StepKinematics/StepKinematics_LowOrderKinematicPair.cxx @@ -0,0 +1,188 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_LowOrderKinematicPair.hxx b/src/StepKinematics/StepKinematics_LowOrderKinematicPair.hxx new file mode 100644 index 0000000000..a7b183cb2d --- /dev/null +++ b/src/StepKinematics/StepKinematics_LowOrderKinematicPair.hxx @@ -0,0 +1,95 @@ +// 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 +#include +#include + +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_LowOrderKinematicPairValue.cxx b/src/StepKinematics/StepKinematics_LowOrderKinematicPairValue.cxx new file mode 100644 index 0000000000..2d283e7d1b --- /dev/null +++ b/src/StepKinematics/StepKinematics_LowOrderKinematicPairValue.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_LowOrderKinematicPairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_LowOrderKinematicPairValue +//purpose : +//======================================================================= + +StepKinematics_LowOrderKinematicPairValue::StepKinematics_LowOrderKinematicPairValue () +{ +} diff --git a/src/StepKinematics/StepKinematics_LowOrderKinematicPairValue.hxx b/src/StepKinematics/StepKinematics_LowOrderKinematicPairValue.hxx new file mode 100644 index 0000000000..b7ea56b3a3 --- /dev/null +++ b/src/StepKinematics/StepKinematics_LowOrderKinematicPairValue.hxx @@ -0,0 +1,40 @@ +// 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 +#include +#include + +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_LowOrderKinematicPairWithMotionCoupling.cxx b/src/StepKinematics/StepKinematics_LowOrderKinematicPairWithMotionCoupling.cxx new file mode 100644 index 0000000000..fa3beefd92 --- /dev/null +++ b/src/StepKinematics/StepKinematics_LowOrderKinematicPairWithMotionCoupling.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_LowOrderKinematicPairWithMotionCoupling, StepKinematics_KinematicPair) + +//======================================================================= +//function : StepKinematics_LowOrderKinematicPairWithMotionCoupling +//purpose : +//======================================================================= + +StepKinematics_LowOrderKinematicPairWithMotionCoupling::StepKinematics_LowOrderKinematicPairWithMotionCoupling () +{ +} diff --git a/src/StepKinematics/StepKinematics_LowOrderKinematicPairWithMotionCoupling.hxx b/src/StepKinematics/StepKinematics_LowOrderKinematicPairWithMotionCoupling.hxx new file mode 100644 index 0000000000..a0f519df03 --- /dev/null +++ b/src/StepKinematics/StepKinematics_LowOrderKinematicPairWithMotionCoupling.hxx @@ -0,0 +1,42 @@ +// 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 +#include +#include + +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_LowOrderKinematicPairWithRange.cxx b/src/StepKinematics/StepKinematics_LowOrderKinematicPairWithRange.cxx new file mode 100644 index 0000000000..836fe02b6d --- /dev/null +++ b/src/StepKinematics/StepKinematics_LowOrderKinematicPairWithRange.cxx @@ -0,0 +1,530 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_LowOrderKinematicPairWithRange.hxx b/src/StepKinematics/StepKinematics_LowOrderKinematicPairWithRange.hxx new file mode 100644 index 0000000000..0833ceda4a --- /dev/null +++ b/src/StepKinematics/StepKinematics_LowOrderKinematicPairWithRange.hxx @@ -0,0 +1,191 @@ +// 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 +#include +#include + +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_MechanismRepresentation.cxx b/src/StepKinematics/StepKinematics_MechanismRepresentation.cxx new file mode 100644 index 0000000000..688bc64109 --- /dev/null +++ b/src/StepKinematics/StepKinematics_MechanismRepresentation.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_MechanismRepresentation, StepRepr_Representation) + +//======================================================================= +//function : StepKinematics_MechanismRepresentation +//purpose : +//======================================================================= + +StepKinematics_MechanismRepresentation::StepKinematics_MechanismRepresentation () +{ +} diff --git a/src/StepKinematics/StepKinematics_MechanismRepresentation.hxx b/src/StepKinematics/StepKinematics_MechanismRepresentation.hxx new file mode 100644 index 0000000000..06a7a97f36 --- /dev/null +++ b/src/StepKinematics/StepKinematics_MechanismRepresentation.hxx @@ -0,0 +1,41 @@ +// 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 +#include +#include + +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_OrientedJoint.cxx b/src/StepKinematics/StepKinematics_OrientedJoint.cxx new file mode 100644 index 0000000000..aae6227d46 --- /dev/null +++ b/src/StepKinematics/StepKinematics_OrientedJoint.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_OrientedJoint, StepShape_OrientedEdge) + +//======================================================================= +//function : StepKinematics_OrientedJoint +//purpose : +//======================================================================= + +StepKinematics_OrientedJoint::StepKinematics_OrientedJoint () +{ +} diff --git a/src/StepKinematics/StepKinematics_OrientedJoint.hxx b/src/StepKinematics/StepKinematics_OrientedJoint.hxx new file mode 100644 index 0000000000..5770b58b59 --- /dev/null +++ b/src/StepKinematics/StepKinematics_OrientedJoint.hxx @@ -0,0 +1,41 @@ +// 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 +#include +#include + +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_PairValue.cxx b/src/StepKinematics/StepKinematics_PairValue.cxx new file mode 100644 index 0000000000..552e23f1f2 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PairValue.cxx @@ -0,0 +1,61 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_PairValue.hxx b/src/StepKinematics/StepKinematics_PairValue.hxx new file mode 100644 index 0000000000..42bb1dda6e --- /dev/null +++ b/src/StepKinematics/StepKinematics_PairValue.hxx @@ -0,0 +1,52 @@ +// 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 +#include +#include + +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_PlanarCurvePair.cxx b/src/StepKinematics/StepKinematics_PlanarCurvePair.cxx new file mode 100644 index 0000000000..2f2c060304 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PlanarCurvePair.cxx @@ -0,0 +1,119 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_PlanarCurvePair.hxx b/src/StepKinematics/StepKinematics_PlanarCurvePair.hxx new file mode 100644 index 0000000000..6a94a77f32 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PlanarCurvePair.hxx @@ -0,0 +1,75 @@ +// 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 +#include +#include + +#include +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_PlanarCurvePairRange.cxx b/src/StepKinematics/StepKinematics_PlanarCurvePairRange.cxx new file mode 100644 index 0000000000..b11d80560e --- /dev/null +++ b/src/StepKinematics/StepKinematics_PlanarCurvePairRange.cxx @@ -0,0 +1,102 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_PlanarCurvePairRange.hxx b/src/StepKinematics/StepKinematics_PlanarCurvePairRange.hxx new file mode 100644 index 0000000000..ecb510304a --- /dev/null +++ b/src/StepKinematics/StepKinematics_PlanarCurvePairRange.hxx @@ -0,0 +1,72 @@ +// 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 +#include +#include + +#include +#include +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_PlanarPair.cxx b/src/StepKinematics/StepKinematics_PlanarPair.cxx new file mode 100644 index 0000000000..1555122a80 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PlanarPair.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_PlanarPair, StepKinematics_LowOrderKinematicPair) + +//======================================================================= +//function : StepKinematics_PlanarPair +//purpose : +//======================================================================= + +StepKinematics_PlanarPair::StepKinematics_PlanarPair () +{ +} diff --git a/src/StepKinematics/StepKinematics_PlanarPair.hxx b/src/StepKinematics/StepKinematics_PlanarPair.hxx new file mode 100644 index 0000000000..19e966f61e --- /dev/null +++ b/src/StepKinematics/StepKinematics_PlanarPair.hxx @@ -0,0 +1,42 @@ +// 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 +#include +#include + +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_PlanarPairValue.cxx b/src/StepKinematics/StepKinematics_PlanarPairValue.cxx new file mode 100644 index 0000000000..4442c12103 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PlanarPairValue.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_PlanarPairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_PlanarPairValue +//purpose : +//======================================================================= + +StepKinematics_PlanarPairValue::StepKinematics_PlanarPairValue () +{ +} diff --git a/src/StepKinematics/StepKinematics_PlanarPairValue.hxx b/src/StepKinematics/StepKinematics_PlanarPairValue.hxx new file mode 100644 index 0000000000..6c877ec6a2 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PlanarPairValue.hxx @@ -0,0 +1,40 @@ +// 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 +#include +#include + +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_PlanarPairWithRange.cxx b/src/StepKinematics/StepKinematics_PlanarPairWithRange.cxx new file mode 100644 index 0000000000..59adce73ab --- /dev/null +++ b/src/StepKinematics/StepKinematics_PlanarPairWithRange.cxx @@ -0,0 +1,296 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_PlanarPairWithRange.hxx b/src/StepKinematics/StepKinematics_PlanarPairWithRange.hxx new file mode 100644 index 0000000000..425d1cb577 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PlanarPairWithRange.hxx @@ -0,0 +1,125 @@ +// 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 +#include +#include + +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_PointOnPlanarCurvePair.cxx b/src/StepKinematics/StepKinematics_PointOnPlanarCurvePair.cxx new file mode 100644 index 0000000000..a12d96305c --- /dev/null +++ b/src/StepKinematics/StepKinematics_PointOnPlanarCurvePair.cxx @@ -0,0 +1,96 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_PointOnPlanarCurvePair.hxx b/src/StepKinematics/StepKinematics_PointOnPlanarCurvePair.hxx new file mode 100644 index 0000000000..eecf1f5ca8 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PointOnPlanarCurvePair.hxx @@ -0,0 +1,68 @@ +// 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 +#include +#include + +#include +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_PointOnPlanarCurvePairValue.cxx b/src/StepKinematics/StepKinematics_PointOnPlanarCurvePairValue.cxx new file mode 100644 index 0000000000..7a034830c1 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PointOnPlanarCurvePairValue.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_PointOnPlanarCurvePairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_PointOnPlanarCurvePairValue +//purpose : +//======================================================================= + +StepKinematics_PointOnPlanarCurvePairValue::StepKinematics_PointOnPlanarCurvePairValue () +{ +} diff --git a/src/StepKinematics/StepKinematics_PointOnPlanarCurvePairValue.hxx b/src/StepKinematics/StepKinematics_PointOnPlanarCurvePairValue.hxx new file mode 100644 index 0000000000..d955a91b00 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PointOnPlanarCurvePairValue.hxx @@ -0,0 +1,40 @@ +// 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 +#include +#include + +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_PointOnPlanarCurvePairWithRange.cxx b/src/StepKinematics/StepKinematics_PointOnPlanarCurvePairWithRange.cxx new file mode 100644 index 0000000000..276c1774be --- /dev/null +++ b/src/StepKinematics/StepKinematics_PointOnPlanarCurvePairWithRange.cxx @@ -0,0 +1,311 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_PointOnPlanarCurvePairWithRange.hxx b/src/StepKinematics/StepKinematics_PointOnPlanarCurvePairWithRange.hxx new file mode 100644 index 0000000000..54ec5e4c28 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PointOnPlanarCurvePairWithRange.hxx @@ -0,0 +1,130 @@ +// 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 +#include +#include + +#include +#include +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_PointOnSurfacePair.cxx b/src/StepKinematics/StepKinematics_PointOnSurfacePair.cxx new file mode 100644 index 0000000000..25467e1e7f --- /dev/null +++ b/src/StepKinematics/StepKinematics_PointOnSurfacePair.cxx @@ -0,0 +1,73 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_PointOnSurfacePair.hxx b/src/StepKinematics/StepKinematics_PointOnSurfacePair.hxx new file mode 100644 index 0000000000..05161e11dd --- /dev/null +++ b/src/StepKinematics/StepKinematics_PointOnSurfacePair.hxx @@ -0,0 +1,61 @@ +// 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 +#include +#include + +#include +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_PointOnSurfacePairValue.cxx b/src/StepKinematics/StepKinematics_PointOnSurfacePairValue.cxx new file mode 100644 index 0000000000..850c8c19e6 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PointOnSurfacePairValue.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_PointOnSurfacePairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_PointOnSurfacePairValue +//purpose : +//======================================================================= + +StepKinematics_PointOnSurfacePairValue::StepKinematics_PointOnSurfacePairValue () +{ +} diff --git a/src/StepKinematics/StepKinematics_PointOnSurfacePairValue.hxx b/src/StepKinematics/StepKinematics_PointOnSurfacePairValue.hxx new file mode 100644 index 0000000000..f2c1d77467 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PointOnSurfacePairValue.hxx @@ -0,0 +1,40 @@ +// 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 +#include +#include + +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_PointOnSurfacePairWithRange.cxx b/src/StepKinematics/StepKinematics_PointOnSurfacePairWithRange.cxx new file mode 100644 index 0000000000..0970eb7e8c --- /dev/null +++ b/src/StepKinematics/StepKinematics_PointOnSurfacePairWithRange.cxx @@ -0,0 +1,309 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_PointOnSurfacePairWithRange.hxx b/src/StepKinematics/StepKinematics_PointOnSurfacePairWithRange.hxx new file mode 100644 index 0000000000..b3aa928a9d --- /dev/null +++ b/src/StepKinematics/StepKinematics_PointOnSurfacePairWithRange.hxx @@ -0,0 +1,129 @@ +// 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 +#include +#include + +#include +#include +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_PrismaticPair.cxx b/src/StepKinematics/StepKinematics_PrismaticPair.cxx new file mode 100644 index 0000000000..567e2b5dc2 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PrismaticPair.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_PrismaticPair, StepKinematics_LowOrderKinematicPair) + +//======================================================================= +//function : StepKinematics_PrismaticPair +//purpose : +//======================================================================= + +StepKinematics_PrismaticPair::StepKinematics_PrismaticPair () +{ +} diff --git a/src/StepKinematics/StepKinematics_PrismaticPair.hxx b/src/StepKinematics/StepKinematics_PrismaticPair.hxx new file mode 100644 index 0000000000..95979803d1 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PrismaticPair.hxx @@ -0,0 +1,42 @@ +// 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 +#include +#include + +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_PrismaticPairValue.cxx b/src/StepKinematics/StepKinematics_PrismaticPairValue.cxx new file mode 100644 index 0000000000..dbf226b4cc --- /dev/null +++ b/src/StepKinematics/StepKinematics_PrismaticPairValue.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_PrismaticPairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_PrismaticPairValue +//purpose : +//======================================================================= + +StepKinematics_PrismaticPairValue::StepKinematics_PrismaticPairValue () +{ +} diff --git a/src/StepKinematics/StepKinematics_PrismaticPairValue.hxx b/src/StepKinematics/StepKinematics_PrismaticPairValue.hxx new file mode 100644 index 0000000000..ec7a30c5a8 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PrismaticPairValue.hxx @@ -0,0 +1,40 @@ +// 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 +#include +#include + +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_PrismaticPairWithRange.cxx b/src/StepKinematics/StepKinematics_PrismaticPairWithRange.cxx new file mode 100644 index 0000000000..1380218a15 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PrismaticPairWithRange.cxx @@ -0,0 +1,140 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_PrismaticPairWithRange.hxx b/src/StepKinematics/StepKinematics_PrismaticPairWithRange.hxx new file mode 100644 index 0000000000..b655932a0f --- /dev/null +++ b/src/StepKinematics/StepKinematics_PrismaticPairWithRange.hxx @@ -0,0 +1,81 @@ +// 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 +#include +#include + +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_ProductDefinitionKinematics.cxx b/src/StepKinematics/StepKinematics_ProductDefinitionKinematics.cxx new file mode 100644 index 0000000000..594628755b --- /dev/null +++ b/src/StepKinematics/StepKinematics_ProductDefinitionKinematics.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_ProductDefinitionKinematics, StepRepr_PropertyDefinition) + +//======================================================================= +//function : StepKinematics_ProductDefinitionKinematics +//purpose : +//======================================================================= + +StepKinematics_ProductDefinitionKinematics::StepKinematics_ProductDefinitionKinematics () +{ +} diff --git a/src/StepKinematics/StepKinematics_ProductDefinitionKinematics.hxx b/src/StepKinematics/StepKinematics_ProductDefinitionKinematics.hxx new file mode 100644 index 0000000000..22ceefd470 --- /dev/null +++ b/src/StepKinematics/StepKinematics_ProductDefinitionKinematics.hxx @@ -0,0 +1,40 @@ +// 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 +#include +#include + +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_ProductDefinitionRelationshipKinematics.cxx b/src/StepKinematics/StepKinematics_ProductDefinitionRelationshipKinematics.cxx new file mode 100644 index 0000000000..b387509c39 --- /dev/null +++ b/src/StepKinematics/StepKinematics_ProductDefinitionRelationshipKinematics.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_ProductDefinitionRelationshipKinematics, StepRepr_PropertyDefinition) + +//======================================================================= +//function : StepKinematics_ProductDefinitionRelationshipKinematics +//purpose : +//======================================================================= + +StepKinematics_ProductDefinitionRelationshipKinematics::StepKinematics_ProductDefinitionRelationshipKinematics () +{ +} diff --git a/src/StepKinematics/StepKinematics_ProductDefinitionRelationshipKinematics.hxx b/src/StepKinematics/StepKinematics_ProductDefinitionRelationshipKinematics.hxx new file mode 100644 index 0000000000..fe220675c2 --- /dev/null +++ b/src/StepKinematics/StepKinematics_ProductDefinitionRelationshipKinematics.hxx @@ -0,0 +1,40 @@ +// 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 +#include +#include + +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_RackAndPinionPair.cxx b/src/StepKinematics/StepKinematics_RackAndPinionPair.cxx new file mode 100644 index 0000000000..e34da05f4b --- /dev/null +++ b/src/StepKinematics/StepKinematics_RackAndPinionPair.cxx @@ -0,0 +1,73 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_RackAndPinionPair.hxx b/src/StepKinematics/StepKinematics_RackAndPinionPair.hxx new file mode 100644 index 0000000000..f2a5244502 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RackAndPinionPair.hxx @@ -0,0 +1,60 @@ +// 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 +#include +#include + +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_RackAndPinionPairValue.cxx b/src/StepKinematics/StepKinematics_RackAndPinionPairValue.cxx new file mode 100644 index 0000000000..20edd2fb10 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RackAndPinionPairValue.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_RackAndPinionPairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_RackAndPinionPairValue +//purpose : +//======================================================================= + +StepKinematics_RackAndPinionPairValue::StepKinematics_RackAndPinionPairValue () +{ +} diff --git a/src/StepKinematics/StepKinematics_RackAndPinionPairValue.hxx b/src/StepKinematics/StepKinematics_RackAndPinionPairValue.hxx new file mode 100644 index 0000000000..e59246bd44 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RackAndPinionPairValue.hxx @@ -0,0 +1,40 @@ +// 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 +#include +#include + +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_RackAndPinionPairWithRange.cxx b/src/StepKinematics/StepKinematics_RackAndPinionPairWithRange.cxx new file mode 100644 index 0000000000..0053e62c56 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RackAndPinionPairWithRange.cxx @@ -0,0 +1,130 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_RackAndPinionPairWithRange.hxx b/src/StepKinematics/StepKinematics_RackAndPinionPairWithRange.hxx new file mode 100644 index 0000000000..5c6ddbec1b --- /dev/null +++ b/src/StepKinematics/StepKinematics_RackAndPinionPairWithRange.hxx @@ -0,0 +1,76 @@ +// 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 +#include +#include + +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_RevolutePair.cxx b/src/StepKinematics/StepKinematics_RevolutePair.cxx new file mode 100644 index 0000000000..69f9f99b99 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RevolutePair.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_RevolutePair, StepKinematics_LowOrderKinematicPair) + +//======================================================================= +//function : StepKinematics_RevolutePair +//purpose : +//======================================================================= + +StepKinematics_RevolutePair::StepKinematics_RevolutePair () +{ +} diff --git a/src/StepKinematics/StepKinematics_RevolutePair.hxx b/src/StepKinematics/StepKinematics_RevolutePair.hxx new file mode 100644 index 0000000000..74f4b746a9 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RevolutePair.hxx @@ -0,0 +1,42 @@ +// 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 +#include +#include + +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_RevolutePairValue.cxx b/src/StepKinematics/StepKinematics_RevolutePairValue.cxx new file mode 100644 index 0000000000..898ccd2582 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RevolutePairValue.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_RevolutePairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_RevolutePairValue +//purpose : +//======================================================================= + +StepKinematics_RevolutePairValue::StepKinematics_RevolutePairValue () +{ +} diff --git a/src/StepKinematics/StepKinematics_RevolutePairValue.hxx b/src/StepKinematics/StepKinematics_RevolutePairValue.hxx new file mode 100644 index 0000000000..6bfaa10026 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RevolutePairValue.hxx @@ -0,0 +1,40 @@ +// 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 +#include +#include + +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_RevolutePairWithRange.cxx b/src/StepKinematics/StepKinematics_RevolutePairWithRange.cxx new file mode 100644 index 0000000000..ef8b9f3ea0 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RevolutePairWithRange.cxx @@ -0,0 +1,140 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_RevolutePairWithRange.hxx b/src/StepKinematics/StepKinematics_RevolutePairWithRange.hxx new file mode 100644 index 0000000000..36ceb51ef2 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RevolutePairWithRange.hxx @@ -0,0 +1,81 @@ +// 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 +#include +#include + +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_RigidPlacement.cxx b/src/StepKinematics/StepKinematics_RigidPlacement.cxx new file mode 100644 index 0000000000..81e6263a41 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RigidPlacement.cxx @@ -0,0 +1,61 @@ +// 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 +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/StepKinematics/StepKinematics_RigidPlacement.hxx b/src/StepKinematics/StepKinematics_RigidPlacement.hxx new file mode 100644 index 0000000000..c955c4861a --- /dev/null +++ b/src/StepKinematics/StepKinematics_RigidPlacement.hxx @@ -0,0 +1,53 @@ +// 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 +#include +#include +#include +#include + +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 diff --git a/src/StepKinematics/StepKinematics_RollingCurvePair.cxx b/src/StepKinematics/StepKinematics_RollingCurvePair.cxx new file mode 100644 index 0000000000..37660d4051 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RollingCurvePair.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_RollingCurvePair, StepKinematics_PlanarCurvePair) + +//======================================================================= +//function : StepKinematics_RollingCurvePair +//purpose : +//======================================================================= + +StepKinematics_RollingCurvePair::StepKinematics_RollingCurvePair () +{ +} diff --git a/src/StepKinematics/StepKinematics_RollingCurvePair.hxx b/src/StepKinematics/StepKinematics_RollingCurvePair.hxx new file mode 100644 index 0000000000..9de67304f5 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RollingCurvePair.hxx @@ -0,0 +1,43 @@ +// 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 +#include +#include + +#include +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_RollingCurvePairValue.cxx b/src/StepKinematics/StepKinematics_RollingCurvePairValue.cxx new file mode 100644 index 0000000000..c40d0c34b9 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RollingCurvePairValue.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_RollingCurvePairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_RollingCurvePairValue +//purpose : +//======================================================================= + +StepKinematics_RollingCurvePairValue::StepKinematics_RollingCurvePairValue () +{ +} diff --git a/src/StepKinematics/StepKinematics_RollingCurvePairValue.hxx b/src/StepKinematics/StepKinematics_RollingCurvePairValue.hxx new file mode 100644 index 0000000000..fd47dccb4b --- /dev/null +++ b/src/StepKinematics/StepKinematics_RollingCurvePairValue.hxx @@ -0,0 +1,40 @@ +// 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 +#include +#include + +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_RollingSurfacePair.cxx b/src/StepKinematics/StepKinematics_RollingSurfacePair.cxx new file mode 100644 index 0000000000..a1d50ce81f --- /dev/null +++ b/src/StepKinematics/StepKinematics_RollingSurfacePair.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_RollingSurfacePair, StepKinematics_SurfacePair) + +//======================================================================= +//function : StepKinematics_RollingSurfacePair +//purpose : +//======================================================================= + +StepKinematics_RollingSurfacePair::StepKinematics_RollingSurfacePair () +{ +} diff --git a/src/StepKinematics/StepKinematics_RollingSurfacePair.hxx b/src/StepKinematics/StepKinematics_RollingSurfacePair.hxx new file mode 100644 index 0000000000..eb79edc14f --- /dev/null +++ b/src/StepKinematics/StepKinematics_RollingSurfacePair.hxx @@ -0,0 +1,43 @@ +// 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 +#include +#include + +#include +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_RollingSurfacePairValue.cxx b/src/StepKinematics/StepKinematics_RollingSurfacePairValue.cxx new file mode 100644 index 0000000000..1b585a9df6 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RollingSurfacePairValue.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_RollingSurfacePairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_RollingSurfacePairValue +//purpose : +//======================================================================= + +StepKinematics_RollingSurfacePairValue::StepKinematics_RollingSurfacePairValue () +{ +} diff --git a/src/StepKinematics/StepKinematics_RollingSurfacePairValue.hxx b/src/StepKinematics/StepKinematics_RollingSurfacePairValue.hxx new file mode 100644 index 0000000000..f61a401838 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RollingSurfacePairValue.hxx @@ -0,0 +1,40 @@ +// 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 +#include +#include + +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_RotationAboutDirection.cxx b/src/StepKinematics/StepKinematics_RotationAboutDirection.cxx new file mode 100644 index 0000000000..40b2165f12 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RotationAboutDirection.cxx @@ -0,0 +1,84 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_RotationAboutDirection.hxx b/src/StepKinematics/StepKinematics_RotationAboutDirection.hxx new file mode 100644 index 0000000000..5f4bb26ebc --- /dev/null +++ b/src/StepKinematics/StepKinematics_RotationAboutDirection.hxx @@ -0,0 +1,59 @@ +// 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 +#include +#include + +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_ScrewPair.cxx b/src/StepKinematics/StepKinematics_ScrewPair.cxx new file mode 100644 index 0000000000..1b6e54cd9d --- /dev/null +++ b/src/StepKinematics/StepKinematics_ScrewPair.cxx @@ -0,0 +1,73 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_ScrewPair.hxx b/src/StepKinematics/StepKinematics_ScrewPair.hxx new file mode 100644 index 0000000000..b2a2521443 --- /dev/null +++ b/src/StepKinematics/StepKinematics_ScrewPair.hxx @@ -0,0 +1,60 @@ +// 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 +#include +#include + +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_ScrewPairValue.cxx b/src/StepKinematics/StepKinematics_ScrewPairValue.cxx new file mode 100644 index 0000000000..045b2f0742 --- /dev/null +++ b/src/StepKinematics/StepKinematics_ScrewPairValue.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_ScrewPairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_ScrewPairValue +//purpose : +//======================================================================= + +StepKinematics_ScrewPairValue::StepKinematics_ScrewPairValue () +{ +} diff --git a/src/StepKinematics/StepKinematics_ScrewPairValue.hxx b/src/StepKinematics/StepKinematics_ScrewPairValue.hxx new file mode 100644 index 0000000000..22b82e4c3b --- /dev/null +++ b/src/StepKinematics/StepKinematics_ScrewPairValue.hxx @@ -0,0 +1,40 @@ +// 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 +#include +#include + +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_ScrewPairWithRange.cxx b/src/StepKinematics/StepKinematics_ScrewPairWithRange.cxx new file mode 100644 index 0000000000..50278e699e --- /dev/null +++ b/src/StepKinematics/StepKinematics_ScrewPairWithRange.cxx @@ -0,0 +1,130 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_ScrewPairWithRange.hxx b/src/StepKinematics/StepKinematics_ScrewPairWithRange.hxx new file mode 100644 index 0000000000..4eb5322750 --- /dev/null +++ b/src/StepKinematics/StepKinematics_ScrewPairWithRange.hxx @@ -0,0 +1,76 @@ +// 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 +#include +#include + +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_SlidingCurvePair.cxx b/src/StepKinematics/StepKinematics_SlidingCurvePair.cxx new file mode 100644 index 0000000000..dc9e060e79 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SlidingCurvePair.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_SlidingCurvePair, StepKinematics_PlanarCurvePair) + +//======================================================================= +//function : StepKinematics_SlidingCurvePair +//purpose : +//======================================================================= + +StepKinematics_SlidingCurvePair::StepKinematics_SlidingCurvePair () +{ +} diff --git a/src/StepKinematics/StepKinematics_SlidingCurvePair.hxx b/src/StepKinematics/StepKinematics_SlidingCurvePair.hxx new file mode 100644 index 0000000000..10d2d6a272 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SlidingCurvePair.hxx @@ -0,0 +1,43 @@ +// 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 +#include +#include + +#include +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_SlidingCurvePairValue.cxx b/src/StepKinematics/StepKinematics_SlidingCurvePairValue.cxx new file mode 100644 index 0000000000..c21d3b1a76 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SlidingCurvePairValue.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_SlidingCurvePairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_SlidingCurvePairValue +//purpose : +//======================================================================= + +StepKinematics_SlidingCurvePairValue::StepKinematics_SlidingCurvePairValue () +{ +} diff --git a/src/StepKinematics/StepKinematics_SlidingCurvePairValue.hxx b/src/StepKinematics/StepKinematics_SlidingCurvePairValue.hxx new file mode 100644 index 0000000000..b05894c56d --- /dev/null +++ b/src/StepKinematics/StepKinematics_SlidingCurvePairValue.hxx @@ -0,0 +1,40 @@ +// 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 +#include +#include + +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_SlidingSurfacePair.cxx b/src/StepKinematics/StepKinematics_SlidingSurfacePair.cxx new file mode 100644 index 0000000000..9df28ac418 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SlidingSurfacePair.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_SlidingSurfacePair, StepKinematics_SurfacePair) + +//======================================================================= +//function : StepKinematics_SlidingSurfacePair +//purpose : +//======================================================================= + +StepKinematics_SlidingSurfacePair::StepKinematics_SlidingSurfacePair () +{ +} diff --git a/src/StepKinematics/StepKinematics_SlidingSurfacePair.hxx b/src/StepKinematics/StepKinematics_SlidingSurfacePair.hxx new file mode 100644 index 0000000000..708300030a --- /dev/null +++ b/src/StepKinematics/StepKinematics_SlidingSurfacePair.hxx @@ -0,0 +1,43 @@ +// 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 +#include +#include + +#include +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_SlidingSurfacePairValue.cxx b/src/StepKinematics/StepKinematics_SlidingSurfacePairValue.cxx new file mode 100644 index 0000000000..69f3936571 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SlidingSurfacePairValue.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_SlidingSurfacePairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_SlidingSurfacePairValue +//purpose : +//======================================================================= + +StepKinematics_SlidingSurfacePairValue::StepKinematics_SlidingSurfacePairValue () +{ +} diff --git a/src/StepKinematics/StepKinematics_SlidingSurfacePairValue.hxx b/src/StepKinematics/StepKinematics_SlidingSurfacePairValue.hxx new file mode 100644 index 0000000000..15e0fefb91 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SlidingSurfacePairValue.hxx @@ -0,0 +1,40 @@ +// 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 +#include +#include + +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_SpatialRotation.cxx b/src/StepKinematics/StepKinematics_SpatialRotation.cxx new file mode 100644 index 0000000000..e38858f6f7 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SpatialRotation.cxx @@ -0,0 +1,61 @@ +// 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 +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/StepKinematics/StepKinematics_SpatialRotation.hxx b/src/StepKinematics/StepKinematics_SpatialRotation.hxx new file mode 100644 index 0000000000..4bfe672c88 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SpatialRotation.hxx @@ -0,0 +1,53 @@ +// 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 +#include +#include +#include +#include + +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 diff --git a/src/StepKinematics/StepKinematics_SphericalPair.cxx b/src/StepKinematics/StepKinematics_SphericalPair.cxx new file mode 100644 index 0000000000..55d77770e9 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SphericalPair.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_SphericalPair, StepKinematics_LowOrderKinematicPair) + +//======================================================================= +//function : StepKinematics_SphericalPair +//purpose : +//======================================================================= + +StepKinematics_SphericalPair::StepKinematics_SphericalPair () +{ +} diff --git a/src/StepKinematics/StepKinematics_SphericalPair.hxx b/src/StepKinematics/StepKinematics_SphericalPair.hxx new file mode 100644 index 0000000000..a9725be111 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SphericalPair.hxx @@ -0,0 +1,42 @@ +// 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 +#include +#include + +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_SphericalPairSelect.cxx b/src/StepKinematics/StepKinematics_SphericalPairSelect.cxx new file mode 100644 index 0000000000..d228e38716 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SphericalPairSelect.cxx @@ -0,0 +1,61 @@ +// 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 +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/StepKinematics/StepKinematics_SphericalPairSelect.hxx b/src/StepKinematics/StepKinematics_SphericalPairSelect.hxx new file mode 100644 index 0000000000..6b0f55cca7 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SphericalPairSelect.hxx @@ -0,0 +1,53 @@ +// 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 +#include +#include +#include +#include + +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 diff --git a/src/StepKinematics/StepKinematics_SphericalPairValue.cxx b/src/StepKinematics/StepKinematics_SphericalPairValue.cxx new file mode 100644 index 0000000000..5faa57f328 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SphericalPairValue.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_SphericalPairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_SphericalPairValue +//purpose : +//======================================================================= + +StepKinematics_SphericalPairValue::StepKinematics_SphericalPairValue () +{ +} diff --git a/src/StepKinematics/StepKinematics_SphericalPairValue.hxx b/src/StepKinematics/StepKinematics_SphericalPairValue.hxx new file mode 100644 index 0000000000..0ed4b2a46e --- /dev/null +++ b/src/StepKinematics/StepKinematics_SphericalPairValue.hxx @@ -0,0 +1,40 @@ +// 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 +#include +#include + +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_SphericalPairWithPin.cxx b/src/StepKinematics/StepKinematics_SphericalPairWithPin.cxx new file mode 100644 index 0000000000..21b2adaff4 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SphericalPairWithPin.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_SphericalPairWithPin, StepKinematics_LowOrderKinematicPair) + +//======================================================================= +//function : StepKinematics_SphericalPairWithPin +//purpose : +//======================================================================= + +StepKinematics_SphericalPairWithPin::StepKinematics_SphericalPairWithPin () +{ +} diff --git a/src/StepKinematics/StepKinematics_SphericalPairWithPin.hxx b/src/StepKinematics/StepKinematics_SphericalPairWithPin.hxx new file mode 100644 index 0000000000..c3748a4013 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SphericalPairWithPin.hxx @@ -0,0 +1,42 @@ +// 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 +#include +#include + +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_SphericalPairWithPinAndRange.cxx b/src/StepKinematics/StepKinematics_SphericalPairWithPinAndRange.cxx new file mode 100644 index 0000000000..fa989ed6b4 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SphericalPairWithPinAndRange.cxx @@ -0,0 +1,218 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_SphericalPairWithPinAndRange.hxx b/src/StepKinematics/StepKinematics_SphericalPairWithPinAndRange.hxx new file mode 100644 index 0000000000..b58d549408 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SphericalPairWithPinAndRange.hxx @@ -0,0 +1,103 @@ +// 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 +#include +#include + +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_SphericalPairWithRange.cxx b/src/StepKinematics/StepKinematics_SphericalPairWithRange.cxx new file mode 100644 index 0000000000..cb8486ddc7 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SphericalPairWithRange.cxx @@ -0,0 +1,296 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_SphericalPairWithRange.hxx b/src/StepKinematics/StepKinematics_SphericalPairWithRange.hxx new file mode 100644 index 0000000000..2601d30fb3 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SphericalPairWithRange.hxx @@ -0,0 +1,125 @@ +// 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 +#include +#include + +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_SuParameters.cxx b/src/StepKinematics/StepKinematics_SuParameters.cxx new file mode 100644 index 0000000000..4ff12486cc --- /dev/null +++ b/src/StepKinematics/StepKinematics_SuParameters.cxx @@ -0,0 +1,176 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_SuParameters.hxx b/src/StepKinematics/StepKinematics_SuParameters.hxx new file mode 100644 index 0000000000..fd2551d5f4 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SuParameters.hxx @@ -0,0 +1,86 @@ +// 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 +#include +#include + +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_SurfacePair.cxx b/src/StepKinematics/StepKinematics_SurfacePair.cxx new file mode 100644 index 0000000000..cac1be8e71 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SurfacePair.cxx @@ -0,0 +1,119 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_SurfacePair.hxx b/src/StepKinematics/StepKinematics_SurfacePair.hxx new file mode 100644 index 0000000000..168839e603 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SurfacePair.hxx @@ -0,0 +1,75 @@ +// 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 +#include +#include + +#include +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_SurfacePairWithRange.cxx b/src/StepKinematics/StepKinematics_SurfacePairWithRange.cxx new file mode 100644 index 0000000000..6cd4f44668 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SurfacePairWithRange.cxx @@ -0,0 +1,180 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_SurfacePairWithRange.hxx b/src/StepKinematics/StepKinematics_SurfacePairWithRange.hxx new file mode 100644 index 0000000000..0fbc348fbe --- /dev/null +++ b/src/StepKinematics/StepKinematics_SurfacePairWithRange.hxx @@ -0,0 +1,94 @@ +// 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 +#include +#include + +#include +#include +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_UnconstrainedPair.cxx b/src/StepKinematics/StepKinematics_UnconstrainedPair.cxx new file mode 100644 index 0000000000..3c3273b27b --- /dev/null +++ b/src/StepKinematics/StepKinematics_UnconstrainedPair.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_UnconstrainedPair, StepKinematics_LowOrderKinematicPair) + +//======================================================================= +//function : StepKinematics_UnconstrainedPair +//purpose : +//======================================================================= + +StepKinematics_UnconstrainedPair::StepKinematics_UnconstrainedPair () +{ +} diff --git a/src/StepKinematics/StepKinematics_UnconstrainedPair.hxx b/src/StepKinematics/StepKinematics_UnconstrainedPair.hxx new file mode 100644 index 0000000000..a0b1fdd207 --- /dev/null +++ b/src/StepKinematics/StepKinematics_UnconstrainedPair.hxx @@ -0,0 +1,42 @@ +// 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 +#include +#include + +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_UnconstrainedPairValue.cxx b/src/StepKinematics/StepKinematics_UnconstrainedPairValue.cxx new file mode 100644 index 0000000000..4d674ac6d2 --- /dev/null +++ b/src/StepKinematics/StepKinematics_UnconstrainedPairValue.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_UnconstrainedPairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_UnconstrainedPairValue +//purpose : +//======================================================================= + +StepKinematics_UnconstrainedPairValue::StepKinematics_UnconstrainedPairValue () +{ +} diff --git a/src/StepKinematics/StepKinematics_UnconstrainedPairValue.hxx b/src/StepKinematics/StepKinematics_UnconstrainedPairValue.hxx new file mode 100644 index 0000000000..da4d6e3222 --- /dev/null +++ b/src/StepKinematics/StepKinematics_UnconstrainedPairValue.hxx @@ -0,0 +1,40 @@ +// 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 +#include +#include + +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_UniversalPair.cxx b/src/StepKinematics/StepKinematics_UniversalPair.cxx new file mode 100644 index 0000000000..62681940eb --- /dev/null +++ b/src/StepKinematics/StepKinematics_UniversalPair.cxx @@ -0,0 +1,101 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_UniversalPair.hxx b/src/StepKinematics/StepKinematics_UniversalPair.hxx new file mode 100644 index 0000000000..902568a19f --- /dev/null +++ b/src/StepKinematics/StepKinematics_UniversalPair.hxx @@ -0,0 +1,70 @@ +// 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 +#include +#include + +#include +#include +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_UniversalPairValue.cxx b/src/StepKinematics/StepKinematics_UniversalPairValue.cxx new file mode 100644 index 0000000000..e9a710f283 --- /dev/null +++ b/src/StepKinematics/StepKinematics_UniversalPairValue.cxx @@ -0,0 +1,28 @@ +// 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 + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_UniversalPairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_UniversalPairValue +//purpose : +//======================================================================= + +StepKinematics_UniversalPairValue::StepKinematics_UniversalPairValue () +{ +} diff --git a/src/StepKinematics/StepKinematics_UniversalPairValue.hxx b/src/StepKinematics/StepKinematics_UniversalPairValue.hxx new file mode 100644 index 0000000000..bc7ea6fbf2 --- /dev/null +++ b/src/StepKinematics/StepKinematics_UniversalPairValue.hxx @@ -0,0 +1,40 @@ +// 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 +#include +#include + +#include +#include + +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_ diff --git a/src/StepKinematics/StepKinematics_UniversalPairWithRange.cxx b/src/StepKinematics/StepKinematics_UniversalPairWithRange.cxx new file mode 100644 index 0000000000..c9cc277e89 --- /dev/null +++ b/src/StepKinematics/StepKinematics_UniversalPairWithRange.cxx @@ -0,0 +1,222 @@ +// 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 + +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; +} diff --git a/src/StepKinematics/StepKinematics_UniversalPairWithRange.hxx b/src/StepKinematics/StepKinematics_UniversalPairWithRange.hxx new file mode 100644 index 0000000000..5073470d88 --- /dev/null +++ b/src/StepKinematics/StepKinematics_UniversalPairWithRange.hxx @@ -0,0 +1,105 @@ +// 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 +#include +#include + +#include +#include +#include +#include + +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_ diff --git a/src/StepRepr/FILES b/src/StepRepr/FILES index 39c589d91e..ab9522c9e3 100644 --- a/src/StepRepr/FILES +++ b/src/StepRepr/FILES @@ -114,10 +114,16 @@ StepRepr_Representation.cxx 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 diff --git a/src/StepRepr/StepRepr_ItemDefinedTransformation.hxx b/src/StepRepr/StepRepr_ItemDefinedTransformation.hxx index 71b35685c2..0dc93d7878 100644 --- a/src/StepRepr/StepRepr_ItemDefinedTransformation.hxx +++ b/src/StepRepr/StepRepr_ItemDefinedTransformation.hxx @@ -42,6 +42,11 @@ public: 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); diff --git a/src/StepRepr/StepRepr_RepresentationContextReference.cxx b/src/StepRepr/StepRepr_RepresentationContextReference.cxx new file mode 100644 index 0000000000..e6087b2c35 --- /dev/null +++ b/src/StepRepr/StepRepr_RepresentationContextReference.cxx @@ -0,0 +1,59 @@ +// 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 + +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; +} diff --git a/src/StepRepr/StepRepr_RepresentationContextReference.hxx b/src/StepRepr/StepRepr_RepresentationContextReference.hxx new file mode 100644 index 0000000000..20a004f972 --- /dev/null +++ b/src/StepRepr/StepRepr_RepresentationContextReference.hxx @@ -0,0 +1,50 @@ +// 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 +#include +#include + +#include + +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_ diff --git a/src/StepRepr/StepRepr_RepresentationOrRepresentationReference.cxx b/src/StepRepr/StepRepr_RepresentationOrRepresentationReference.cxx new file mode 100644 index 0000000000..a2580e6ca4 --- /dev/null +++ b/src/StepRepr/StepRepr_RepresentationOrRepresentationReference.cxx @@ -0,0 +1,61 @@ +// 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 +#include +#include + +//======================================================================= +//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()); +} diff --git a/src/StepRepr/StepRepr_RepresentationOrRepresentationReference.hxx b/src/StepRepr/StepRepr_RepresentationOrRepresentationReference.hxx new file mode 100644 index 0000000000..9680bcd2a2 --- /dev/null +++ b/src/StepRepr/StepRepr_RepresentationOrRepresentationReference.hxx @@ -0,0 +1,53 @@ +// 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 +#include +#include +#include +#include + +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 diff --git a/src/StepRepr/StepRepr_RepresentationReference.cxx b/src/StepRepr/StepRepr_RepresentationReference.cxx new file mode 100644 index 0000000000..02dc4b89dd --- /dev/null +++ b/src/StepRepr/StepRepr_RepresentationReference.cxx @@ -0,0 +1,82 @@ +// 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 + +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; +} diff --git a/src/StepRepr/StepRepr_RepresentationReference.hxx b/src/StepRepr/StepRepr_RepresentationReference.hxx new file mode 100644 index 0000000000..7e0a27b634 --- /dev/null +++ b/src/StepRepr/StepRepr_RepresentationReference.hxx @@ -0,0 +1,58 @@ +// 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 +#include +#include + +#include +#include + +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_ diff --git a/src/StepRepr/StepRepr_RepresentationRelationship.hxx b/src/StepRepr/StepRepr_RepresentationRelationship.hxx index 3577e2784a..ad953cc35d 100644 --- a/src/StepRepr/StepRepr_RepresentationRelationship.hxx +++ b/src/StepRepr/StepRepr_RepresentationRelationship.hxx @@ -43,6 +43,11 @@ public: 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); diff --git a/src/TKSTEPAttr/PACKAGES b/src/TKSTEPAttr/PACKAGES index fcd9709c45..b6bf50c60d 100755 --- a/src/TKSTEPAttr/PACKAGES +++ b/src/TKSTEPAttr/PACKAGES @@ -2,3 +2,5 @@ StepVisual RWStepVisual StepDimTol RWStepDimTol +StepKinematics +RWStepKinematics