diff --git a/adm/UDLIST b/adm/UDLIST index f5d2176244..4cc783fdd6 100644 --- a/adm/UDLIST +++ b/adm/UDLIST @@ -328,6 +328,7 @@ n RWStepDimTol n RWStepElement n RWStepFEA n RWStepGeom +n RWStepKinematics n RWStepRepr n RWStepShape n RWStepVisual @@ -347,6 +348,7 @@ n StepDimTol n StepElement n StepFEA n StepGeom +n StepKinematics n StepRepr n StepSelect n StepShape diff --git a/src/RWStepAP214/RWStepAP214_GeneralModule.cxx b/src/RWStepAP214/RWStepAP214_GeneralModule.cxx index 55ea79fee6..cea13b4ee6 100644 --- a/src/RWStepAP214/RWStepAP214_GeneralModule.cxx +++ b/src/RWStepAP214/RWStepAP214_GeneralModule.cxx @@ -348,6 +348,7 @@ #include #include #include +#include #include #include #include @@ -381,6 +382,8 @@ #include #include #include +#include +#include #include #include #include @@ -872,6 +875,7 @@ #include #include #include +#include #include #include #include @@ -923,8 +927,10 @@ #include #include #include +#include #include #include +#include #include #include #include @@ -1366,6 +1372,158 @@ IMPLEMENT_STANDARD_RTTIEXT(RWStepAP214_GeneralModule,StepData_GeneralModule) #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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + static Standard_Integer catsh,catdr,catstr,catdsc,cataux; @@ -5193,6 +5351,546 @@ void RWStepAP214_GeneralModule::FillSharedCase(const Standard_Integer CN, tool.Share(anent, iter); } break; + case 724: + { + DeclareAndCast(StepRepr_RepresentationContextReference, anent, ent); + RWStepRepr_RWRepresentationContextReference tool; + tool.Share(anent, iter); + } + break; + case 725: + { + DeclareAndCast(StepRepr_RepresentationReference, anent, ent); + RWStepRepr_RWRepresentationReference tool; + tool.Share(anent, iter); + } + break; + case 726: + { + DeclareAndCast(StepGeom_SuParameters, anent, ent); + RWStepGeom_RWSuParameters tool; + tool.Share(anent, iter); + } + break; + case 727: + { + DeclareAndCast(StepKinematics_RotationAboutDirection, anent, ent); + RWStepKinematics_RWRotationAboutDirection tool; + tool.Share(anent, iter); + } + break; + case 728: + { + DeclareAndCast(StepKinematics_KinematicJoint, anent, ent); + RWStepKinematics_RWKinematicJoint tool; + tool.Share(anent, iter); + } + break; + case 729: + { + DeclareAndCast(StepKinematics_ActuatedKinematicPair, anent, ent); + RWStepKinematics_RWActuatedKinematicPair tool; + tool.Share(anent, iter); + } + break; + case 730: + { + DeclareAndCast(StepKinematics_ContextDependentKinematicLinkRepresentation, anent, ent); + RWStepKinematics_RWContextDependentKinematicLinkRepresentation tool; + tool.Share(anent, iter); + } + break; + case 731: + { + DeclareAndCast(StepKinematics_CylindricalPair, anent, ent); + RWStepKinematics_RWCylindricalPair tool; + tool.Share(anent, iter); + } + break; + case 732: + { + DeclareAndCast(StepKinematics_CylindricalPairValue, anent, ent); + RWStepKinematics_RWCylindricalPairValue tool; + tool.Share(anent, iter); + } + break; + case 733: + { + DeclareAndCast(StepKinematics_CylindricalPairWithRange, anent, ent); + RWStepKinematics_RWCylindricalPairWithRange tool; + tool.Share(anent, iter); + } + break; + case 734: + { + DeclareAndCast(StepKinematics_FullyConstrainedPair, anent, ent); + RWStepKinematics_RWFullyConstrainedPair tool; + tool.Share(anent, iter); + } + break; + case 735: + { + DeclareAndCast(StepKinematics_GearPair, anent, ent); + RWStepKinematics_RWGearPair tool; + tool.Share(anent, iter); + } + break; + case 736: + { + DeclareAndCast(StepKinematics_GearPairValue, anent, ent); + RWStepKinematics_RWGearPairValue tool; + tool.Share(anent, iter); + } + break; + case 737: + { + DeclareAndCast(StepKinematics_GearPairWithRange, anent, ent); + RWStepKinematics_RWGearPairWithRange tool; + tool.Share(anent, iter); + } + break; + case 738: + { + DeclareAndCast(StepKinematics_HomokineticPair, anent, ent); + RWStepKinematics_RWHomokineticPair tool; + tool.Share(anent, iter); + } + break; + case 739: + { + DeclareAndCast(StepKinematics_KinematicLink, anent, ent); + RWStepKinematics_RWKinematicLink tool; + tool.Share(anent, iter); + } + break; + case 740: + { + DeclareAndCast(StepKinematics_KinematicLinkRepresentationAssociation, anent, ent); + RWStepKinematics_RWKinematicLinkRepresentationAssociation tool; + tool.Share(anent, iter); + } + break; + case 741: + { + DeclareAndCast(StepKinematics_KinematicPropertyMechanismRepresentation, anent, ent); + RWStepKinematics_RWKinematicPropertyMechanismRepresentation tool; + tool.Share(anent, iter); + } + break; + case 742: + { + DeclareAndCast(StepKinematics_KinematicTopologyStructure, anent, ent); + RWStepKinematics_RWKinematicTopologyStructure tool; + tool.Share(anent, iter); + } + break; + case 743: + { + DeclareAndCast(StepKinematics_LowOrderKinematicPair, anent, ent); + RWStepKinematics_RWLowOrderKinematicPair tool; + tool.Share(anent, iter); + } + break; + case 744: + { + DeclareAndCast(StepKinematics_LowOrderKinematicPairValue, anent, ent); + RWStepKinematics_RWLowOrderKinematicPairValue tool; + tool.Share(anent, iter); + } + break; + case 745: + { + DeclareAndCast(StepKinematics_LowOrderKinematicPairWithRange, anent, ent); + RWStepKinematics_RWLowOrderKinematicPairWithRange tool; + tool.Share(anent, iter); + } + break; + case 746: + { + DeclareAndCast(StepKinematics_MechanismRepresentation, anent, ent); + RWStepKinematics_RWMechanismRepresentation tool; + tool.Share(anent, iter); + } + break; + case 747: + { + DeclareAndCast(StepKinematics_OrientedJoint, anent, ent); + RWStepKinematics_RWOrientedJoint tool; + tool.Share(anent, iter); + } + break; + case 748: + { + DeclareAndCast(StepKinematics_PlanarCurvePair, anent, ent); + RWStepKinematics_RWPlanarCurvePair tool; + tool.Share(anent, iter); + } + break; + case 749: + { + DeclareAndCast(StepKinematics_PlanarCurvePairRange, anent, ent); + RWStepKinematics_RWPlanarCurvePairRange tool; + tool.Share(anent, iter); + } + break; + case 750: + { + DeclareAndCast(StepKinematics_PlanarPair, anent, ent); + RWStepKinematics_RWPlanarPair tool; + tool.Share(anent, iter); + } + break; + case 751: + { + DeclareAndCast(StepKinematics_PlanarPairValue, anent, ent); + RWStepKinematics_RWPlanarPairValue tool; + tool.Share(anent, iter); + } + break; + case 752: + { + DeclareAndCast(StepKinematics_PlanarPairWithRange, anent, ent); + RWStepKinematics_RWPlanarPairWithRange tool; + tool.Share(anent, iter); + } + break; + case 753: + { + DeclareAndCast(StepKinematics_PointOnPlanarCurvePair, anent, ent); + RWStepKinematics_RWPointOnPlanarCurvePair tool; + tool.Share(anent, iter); + } + break; + case 754: + { + DeclareAndCast(StepKinematics_PointOnPlanarCurvePairValue, anent, ent); + RWStepKinematics_RWPointOnPlanarCurvePairValue tool; + tool.Share(anent, iter); + } + break; + case 755: + { + DeclareAndCast(StepKinematics_PointOnPlanarCurvePairWithRange, anent, ent); + RWStepKinematics_RWPointOnPlanarCurvePairWithRange tool; + tool.Share(anent, iter); + } + break; + case 756: + { + DeclareAndCast(StepKinematics_PointOnSurfacePair, anent, ent); + RWStepKinematics_RWPointOnSurfacePair tool; + tool.Share(anent, iter); + } + break; + case 757: + { + DeclareAndCast(StepKinematics_PointOnSurfacePairValue, anent, ent); + RWStepKinematics_RWPointOnSurfacePairValue tool; + tool.Share(anent, iter); + } + break; + case 758: + { + DeclareAndCast(StepKinematics_PointOnSurfacePairWithRange, anent, ent); + RWStepKinematics_RWPointOnSurfacePairWithRange tool; + tool.Share(anent, iter); + } + break; + case 759: + { + DeclareAndCast(StepKinematics_PrismaticPair, anent, ent); + RWStepKinematics_RWPrismaticPair tool; + tool.Share(anent, iter); + } + break; + case 760: + { + DeclareAndCast(StepKinematics_PrismaticPairValue, anent, ent); + RWStepKinematics_RWPrismaticPairValue tool; + tool.Share(anent, iter); + } + break; + case 761: + { + DeclareAndCast(StepKinematics_PrismaticPairWithRange, anent, ent); + RWStepKinematics_RWPrismaticPairWithRange tool; + tool.Share(anent, iter); + } + break; + case 762: + { + DeclareAndCast(StepKinematics_ProductDefinitionKinematics, anent, ent); + RWStepKinematics_RWProductDefinitionKinematics tool; + tool.Share(anent, iter); + } + break; + case 763: + { + DeclareAndCast(StepKinematics_ProductDefinitionRelationshipKinematics, anent, ent); + RWStepKinematics_RWProductDefinitionRelationshipKinematics tool; + tool.Share(anent, iter); + } + break; + case 764: + { + DeclareAndCast(StepKinematics_RackAndPinionPair, anent, ent); + RWStepKinematics_RWRackAndPinionPair tool; + tool.Share(anent, iter); + } + break; + case 765: + { + DeclareAndCast(StepKinematics_RackAndPinionPairValue, anent, ent); + RWStepKinematics_RWRackAndPinionPairValue tool; + tool.Share(anent, iter); + } + break; + case 766: + { + DeclareAndCast(StepKinematics_RackAndPinionPairWithRange, anent, ent); + RWStepKinematics_RWRackAndPinionPairWithRange tool; + tool.Share(anent, iter); + } + break; + case 767: + { + DeclareAndCast(StepKinematics_RevolutePair, anent, ent); + RWStepKinematics_RWRevolutePair tool; + tool.Share(anent, iter); + } + break; + case 768: + { + DeclareAndCast(StepKinematics_RevolutePairValue, anent, ent); + RWStepKinematics_RWRevolutePairValue tool; + tool.Share(anent, iter); + } + break; + case 769: + { + DeclareAndCast(StepKinematics_RevolutePairWithRange, anent, ent); + RWStepKinematics_RWRevolutePairWithRange tool; + tool.Share(anent, iter); + } + break; + case 770: + { + DeclareAndCast(StepKinematics_RollingCurvePair, anent, ent); + RWStepKinematics_RWRollingCurvePair tool; + tool.Share(anent, iter); + } + break; + case 771: + { + DeclareAndCast(StepKinematics_RollingCurvePairValue, anent, ent); + RWStepKinematics_RWRollingCurvePairValue tool; + tool.Share(anent, iter); + } + break; + case 772: + { + DeclareAndCast(StepKinematics_RollingSurfacePair, anent, ent); + RWStepKinematics_RWRollingSurfacePair tool; + tool.Share(anent, iter); + } + break; + case 773: + { + DeclareAndCast(StepKinematics_RollingSurfacePairValue, anent, ent); + RWStepKinematics_RWRollingSurfacePairValue tool; + tool.Share(anent, iter); + } + break; + case 774: + { + DeclareAndCast(StepKinematics_ScrewPair, anent, ent); + RWStepKinematics_RWScrewPair tool; + tool.Share(anent, iter); + } + break; + case 775: + { + DeclareAndCast(StepKinematics_ScrewPairValue, anent, ent); + RWStepKinematics_RWScrewPairValue tool; + tool.Share(anent, iter); + } + break; + case 776: + { + DeclareAndCast(StepKinematics_ScrewPairWithRange, anent, ent); + RWStepKinematics_RWScrewPairWithRange tool; + tool.Share(anent, iter); + } + break; + case 777: + { + DeclareAndCast(StepKinematics_SlidingCurvePair, anent, ent); + RWStepKinematics_RWSlidingCurvePair tool; + tool.Share(anent, iter); + } + break; + case 778: + { + DeclareAndCast(StepKinematics_SlidingCurvePairValue, anent, ent); + RWStepKinematics_RWSlidingCurvePairValue tool; + tool.Share(anent, iter); + } + break; + case 779: + { + DeclareAndCast(StepKinematics_SlidingSurfacePair, anent, ent); + RWStepKinematics_RWSlidingSurfacePair tool; + tool.Share(anent, iter); + } + break; + case 780: + { + DeclareAndCast(StepKinematics_SlidingSurfacePairValue, anent, ent); + RWStepKinematics_RWSlidingSurfacePairValue tool; + tool.Share(anent, iter); + } + break; + case 781: + { + DeclareAndCast(StepKinematics_SphericalPair, anent, ent); + RWStepKinematics_RWSphericalPair tool; + tool.Share(anent, iter); + } + break; + case 782: + { + DeclareAndCast(StepKinematics_SphericalPairValue, anent, ent); + RWStepKinematics_RWSphericalPairValue tool; + tool.Share(anent, iter); + } + break; + case 783: + { + DeclareAndCast(StepKinematics_SphericalPairWithPin, anent, ent); + RWStepKinematics_RWSphericalPairWithPin tool; + tool.Share(anent, iter); + } + break; + case 784: + { + DeclareAndCast(StepKinematics_SphericalPairWithPinAndRange, anent, ent); + RWStepKinematics_RWSphericalPairWithPinAndRange tool; + tool.Share(anent, iter); + } + break; + case 785: + { + DeclareAndCast(StepKinematics_SphericalPairWithRange, anent, ent); + RWStepKinematics_RWSphericalPairWithRange tool; + tool.Share(anent, iter); + } + break; + case 786: + { + DeclareAndCast(StepKinematics_SurfacePairWithRange, anent, ent); + RWStepKinematics_RWSurfacePairWithRange tool; + tool.Share(anent, iter); + } + break; + case 787: + { + DeclareAndCast(StepKinematics_UnconstrainedPair, anent, ent); + RWStepKinematics_RWUnconstrainedPair tool; + tool.Share(anent, iter); + } + break; + case 788: + { + DeclareAndCast(StepKinematics_UnconstrainedPairValue, anent, ent); + RWStepKinematics_RWUnconstrainedPairValue tool; + tool.Share(anent, iter); + } + break; + case 789: + { + DeclareAndCast(StepKinematics_UniversalPair, anent, ent); + RWStepKinematics_RWUniversalPair tool; + tool.Share(anent, iter); + } + break; + case 790: + { + DeclareAndCast(StepKinematics_UniversalPairValue, anent, ent); + RWStepKinematics_RWUniversalPairValue tool; + tool.Share(anent, iter); + } + break; + case 791: + { + DeclareAndCast(StepKinematics_UniversalPairWithRange, anent, ent); + RWStepKinematics_RWUniversalPairWithRange tool; + tool.Share(anent, iter); + } + break; + case 792: + { + DeclareAndCast(StepKinematics_PairRepresentationRelationship, anent, ent); + RWStepKinematics_RWPairRepresentationRelationship tool; + tool.Share(anent, iter); + } + break; + case 793: + { + DeclareAndCast(StepKinematics_RigidLinkRepresentation, anent, ent); + RWStepKinematics_RWRigidLinkRepresentation tool; + tool.Share(anent, iter); + } + break; + case 794: + { + DeclareAndCast(StepKinematics_KinematicTopologyDirectedStructure, anent, ent); + RWStepKinematics_RWKinematicTopologyDirectedStructure tool; + tool.Share(anent, iter); + } + break; + case 795: + { + DeclareAndCast(StepKinematics_KinematicTopologyNetworkStructure, anent, ent); + RWStepKinematics_RWKinematicTopologyNetworkStructure tool; + tool.Share(anent, iter); + } + break; + case 796: + { + DeclareAndCast(StepKinematics_LinearFlexibleAndPinionPair, anent, ent); + RWStepKinematics_RWLinearFlexibleAndPinionPair tool; + tool.Share(anent, iter); + } + break; + case 797: + { + DeclareAndCast(StepKinematics_LinearFlexibleAndPlanarCurvePair, anent, ent); + RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair tool; + tool.Share(anent, iter); + } + break; + case 798: + { + DeclareAndCast(StepKinematics_LinearFlexibleLinkRepresentation, anent, ent); + RWStepKinematics_RWLinearFlexibleLinkRepresentation tool; + tool.Share(anent, iter); + } + break; + case 800: + { + DeclareAndCast(StepKinematics_ActuatedKinPairAndOrderKinPair, anent, ent); + RWStepKinematics_RWActuatedKinPairAndOrderKinPair tool; + tool.Share(anent, iter); + } + break; + case 801: + { + DeclareAndCast(StepKinematics_MechanismStateRepresentation, anent, ent); + RWStepKinematics_RWMechanismStateRepresentation tool; + tool.Share(anent, iter); + } + break; + default : break; } } @@ -7217,6 +7915,238 @@ Standard_Boolean RWStepAP214_GeneralModule::NewVoid case 723: ent = new StepVisual_SurfaceStyleRenderingWithProperties; break; + case 724: + ent = new StepRepr_RepresentationContextReference; + break; + case 725: + ent = new StepRepr_RepresentationReference; + break; + case 726: + ent = new StepGeom_SuParameters; + break; + case 727: + ent = new StepKinematics_RotationAboutDirection; + break; + case 728: + ent = new StepKinematics_KinematicJoint; + break; + case 729: + ent = new StepKinematics_ActuatedKinematicPair; + break; + case 730: + ent = new StepKinematics_ContextDependentKinematicLinkRepresentation; + break; + case 731: + ent = new StepKinematics_CylindricalPair; + break; + case 732: + ent = new StepKinematics_CylindricalPairValue; + break; + case 733: + ent = new StepKinematics_CylindricalPairWithRange; + break; + case 734: + ent = new StepKinematics_FullyConstrainedPair; + break; + case 735: + ent = new StepKinematics_GearPair; + break; + case 736: + ent = new StepKinematics_GearPairValue; + break; + case 737: + ent = new StepKinematics_GearPairWithRange; + break; + case 738: + ent = new StepKinematics_HomokineticPair; + break; + case 739: + ent = new StepKinematics_KinematicLink; + break; + case 740: + ent = new StepKinematics_KinematicLinkRepresentationAssociation; + break; + case 741: + ent = new StepKinematics_KinematicPropertyMechanismRepresentation; + break; + case 742: + ent = new StepKinematics_KinematicTopologyStructure; + break; + case 743: + ent = new StepKinematics_LowOrderKinematicPair; + break; + case 744: + ent = new StepKinematics_LowOrderKinematicPairValue; + break; + case 745: + ent = new StepKinematics_LowOrderKinematicPairWithRange; + break; + case 746: + ent = new StepKinematics_MechanismRepresentation; + break; + case 747: + ent = new StepKinematics_OrientedJoint; + break; + case 748: + ent = new StepKinematics_PlanarCurvePair; + break; + case 749: + ent = new StepKinematics_PlanarCurvePairRange; + break; + case 750: + ent = new StepKinematics_PlanarPair; + break; + case 751: + ent = new StepKinematics_PlanarPairValue; + break; + case 752: + ent = new StepKinematics_PlanarPairWithRange; + break; + case 753: + ent = new StepKinematics_PointOnPlanarCurvePair; + break; + case 754: + ent = new StepKinematics_PointOnPlanarCurvePairValue; + break; + case 755: + ent = new StepKinematics_PointOnPlanarCurvePairWithRange; + break; + case 756: + ent = new StepKinematics_PointOnSurfacePair; + break; + case 757: + ent = new StepKinematics_PointOnSurfacePairValue; + break; + case 758: + ent = new StepKinematics_PointOnSurfacePairWithRange; + break; + case 759: + ent = new StepKinematics_PrismaticPair; + break; + case 760: + ent = new StepKinematics_PrismaticPairValue; + break; + case 761: + ent = new StepKinematics_PrismaticPairWithRange; + break; + case 762: + ent = new StepKinematics_ProductDefinitionKinematics; + break; + case 763: + ent = new StepKinematics_ProductDefinitionRelationshipKinematics; + break; + case 764: + ent = new StepKinematics_RackAndPinionPair; + break; + case 765: + ent = new StepKinematics_RackAndPinionPairValue; + break; + case 766: + ent = new StepKinematics_RackAndPinionPairWithRange; + break; + case 767: + ent = new StepKinematics_RevolutePair; + break; + case 768: + ent = new StepKinematics_RevolutePairValue; + break; + case 769: + ent = new StepKinematics_RevolutePairWithRange; + break; + case 770: + ent = new StepKinematics_RollingCurvePair; + break; + case 771: + ent = new StepKinematics_RollingCurvePairValue; + break; + case 772: + ent = new StepKinematics_RollingSurfacePair; + break; + case 773: + ent = new StepKinematics_RollingSurfacePairValue; + break; + case 774: + ent = new StepKinematics_ScrewPair; + break; + case 775: + ent = new StepKinematics_ScrewPairValue; + break; + case 776: + ent = new StepKinematics_ScrewPairWithRange; + break; + case 777: + ent = new StepKinematics_SlidingCurvePair; + break; + case 778: + ent = new StepKinematics_SlidingCurvePairValue; + break; + case 779: + ent = new StepKinematics_SlidingSurfacePair; + break; + case 780: + ent = new StepKinematics_SlidingSurfacePairValue; + break; + case 781: + ent = new StepKinematics_SphericalPair; + break; + case 782: + ent = new StepKinematics_SphericalPairValue; + break; + case 783: + ent = new StepKinematics_SphericalPairWithPin; + break; + case 784: + ent = new StepKinematics_SphericalPairWithPinAndRange; + break; + case 785: + ent = new StepKinematics_SphericalPairWithRange; + break; + case 786: + ent = new StepKinematics_SurfacePairWithRange; + break; + case 787: + ent = new StepKinematics_UnconstrainedPair; + break; + case 788: + ent = new StepKinematics_UnconstrainedPairValue; + break; + case 789: + ent = new StepKinematics_UniversalPair; + break; + case 790: + ent = new StepKinematics_UniversalPairValue; + break; + case 791: + ent = new StepKinematics_UniversalPairWithRange; + break; + case 792: + ent = new StepKinematics_PairRepresentationRelationship; + break; + case 793: + ent = new StepKinematics_RigidLinkRepresentation; + break; + case 794: + ent = new StepKinematics_KinematicTopologyDirectedStructure; + break; + case 795: + ent = new StepKinematics_KinematicTopologyNetworkStructure; + break; + case 796: + ent = new StepKinematics_LinearFlexibleAndPinionPair; + break; + case 797: + ent = new StepKinematics_LinearFlexibleAndPlanarCurvePair; + break; + case 798: + ent = new StepKinematics_LinearFlexibleLinkRepresentation; + break; + case 800: + ent = new StepKinematics_ActuatedKinPairAndOrderKinPair; + break; + case 801: + ent = new StepKinematics_MechanismStateRepresentation; + break; + default: return Standard_False; } @@ -7819,7 +8749,83 @@ Standard_Integer RWStepAP214_GeneralModule::CategoryNumber case 721: case 722: case 723: return catdr; - + case 724: return cataux; + case 725: return cataux; + case 726: return cataux; + case 727: return cataux; + case 728: return cataux; + case 729: return cataux; + case 730: return cataux; + case 731: return cataux; + case 732: return cataux; + case 733: return cataux; + case 734: return cataux; + case 735: return cataux; + case 736: return cataux; + case 737: return cataux; + case 738: return cataux; + case 739: return cataux; + case 740: return cataux; + case 741: return cataux; + case 742: return cataux; + case 743: return cataux; + case 744: return cataux; + case 745: return cataux; + case 746: return cataux; + case 747: return cataux; + case 748: return cataux; + case 749: return cataux; + case 750: return cataux; + case 751: return cataux; + case 752: return cataux; + case 753: return cataux; + case 754: return cataux; + case 755: return cataux; + case 756: return cataux; + case 757: return cataux; + case 758: return cataux; + case 759: return cataux; + case 760: return cataux; + case 761: return cataux; + case 762: return cataux; + case 763: return cataux; + case 764: return cataux; + case 765: return cataux; + case 766: return cataux; + case 767: return cataux; + case 768: return cataux; + case 769: return cataux; + case 770: return cataux; + case 771: return cataux; + case 772: return cataux; + case 773: return cataux; + case 774: return cataux; + case 775: return cataux; + case 776: return cataux; + case 777: return cataux; + case 778: return cataux; + case 779: return cataux; + case 780: return cataux; + case 781: return cataux; + case 782: return cataux; + case 783: return cataux; + case 784: return cataux; + case 785: return cataux; + case 786: return cataux; + case 787: return cataux; + case 788: return cataux; + case 789: return cataux; + case 790: return cataux; + case 791: return cataux; + case 792: return cataux; + case 793: return cataux; + case 794: return cataux; + case 795: return cataux; + case 796: return cataux; + case 797: return cataux; + case 798: return cataux; + case 800: return catsh; + case 801: return cataux; default : break; } return 0; diff --git a/src/RWStepAP214/RWStepAP214_ReadWriteModule.cxx b/src/RWStepAP214/RWStepAP214_ReadWriteModule.cxx index 2e7bcb36d8..fbc05b8024 100644 --- a/src/RWStepAP214/RWStepAP214_ReadWriteModule.cxx +++ b/src/RWStepAP214/RWStepAP214_ReadWriteModule.cxx @@ -1414,6 +1414,164 @@ IMPLEMENT_STANDARD_RTTIEXT(RWStepAP214_ReadWriteModule,StepData_ReadWriteModule) #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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + // -- General Declarations (Recognize, StepType) --- static TCollection_AsciiString PasReco("?"); @@ -2060,6 +2218,84 @@ static TCollection_AsciiString Reco_SurfaceStyleReflectanceAmbient("SURFACE_STYL static TCollection_AsciiString Reco_SurfaceStyleRendering("SURFACE_STYLE_RENDERING"); static TCollection_AsciiString Reco_SurfaceStyleRenderingWithProperties("SURFACE_STYLE_RENDERING_WITH_PROPERTIES"); +static TCollection_AsciiString Reco_RepresentationContextReference("REPRESENTATION_CONTEXT_REFERENCE"); +static TCollection_AsciiString Reco_RepresentationReference("REPRESENTATION_REFERENCE"); +static TCollection_AsciiString Reco_SuParameters("SU_PARAMETERS"); +static TCollection_AsciiString Reco_RotationAboutDirection("ROTATION_ABOUT_DIRECTION"); +static TCollection_AsciiString Reco_KinematicJoint("KINEMATIC_JOINT"); +static TCollection_AsciiString Reco_ActuatedKinematicPair("ACTUATED_KINEMATIC_PAIR"); +static TCollection_AsciiString Reco_ContextDependentKinematicLinkRepresentation("CONTEXT_DEPENDENT_KINEMATIC_LINK_REPRESENTATION"); +static TCollection_AsciiString Reco_CylindricalPair("CYLINDRICAL_PAIR"); +static TCollection_AsciiString Reco_CylindricalPairValue("CYLINDRICAL_PAIR_VALUE"); +static TCollection_AsciiString Reco_CylindricalPairWithRange("CYLINDRICAL_PAIR_WITH_RANGE"); +static TCollection_AsciiString Reco_FullyConstrainedPair("FULLY_CONSTRAINED_PAIR"); +static TCollection_AsciiString Reco_GearPair("GEAR_PAIR"); +static TCollection_AsciiString Reco_GearPairValue("GEAR_PAIR_VALUE"); +static TCollection_AsciiString Reco_GearPairWithRange("GEAR_PAIR_WITH_RANGE"); +static TCollection_AsciiString Reco_HomokineticPair("HOMOKINETIC_PAIR"); +static TCollection_AsciiString Reco_KinematicLink("KINEMATIC_LINK"); +static TCollection_AsciiString Reco_KinematicLinkRepresentationAssociation("KINEMATIC_LINK_REPRESENTATION_ASSOCIATION"); +static TCollection_AsciiString Reco_KinematicPropertyMechanismRepresentation("KINEMATIC_PROPERTY_MECHANISM_REPRESENTATION"); +static TCollection_AsciiString Reco_KinematicTopologyDirectedStructure("KINEMATIC_TOPOLOGY_DIRECTED_STRUCTURE"); +static TCollection_AsciiString Reco_KinematicTopologyNetworkStructure("KINEMATIC_TOPOLOGY_NETWORK_STRUCTURE"); +static TCollection_AsciiString Reco_KinematicTopologyStructure("KINEMATIC_TOPOLOGY_STRUCTURE"); +static TCollection_AsciiString Reco_LinearFlexibleAndPinionPair("LINEAR_FLEXIBLE_AND_PINION_PAIR"); +static TCollection_AsciiString Reco_LinearFlexibleAndPlanarCurvePair("LINEAR_FLEXIBLE_AND_PLANAR_CURVE_PAIR"); +static TCollection_AsciiString Reco_LinearFlexibleLinkRepresentation("LINEAR_FLEXIBLE_LINK_REPRESENTATION"); +static TCollection_AsciiString Reco_LowOrderKinematicPair("LOW_ORDER_KINEMATIC_PAIR"); +static TCollection_AsciiString Reco_LowOrderKinematicPairValue("LOW_ORDER_KINEMATIC_PAIR_VALUE"); +static TCollection_AsciiString Reco_LowOrderKinematicPairWithRange("LOW_ORDER_KINEMATIC_PAIR_WITH_RANGE"); +static TCollection_AsciiString Reco_MechanismRepresentation("MECHANISM_REPRESENTATION"); +static TCollection_AsciiString Reco_OrientedJoint("ORIENTED_JOINT"); +static TCollection_AsciiString Reco_PairRepresentationRelationship("PAIR_REPRESENTATION_RELATIONSHIP"); +static TCollection_AsciiString Reco_PlanarCurvePair("PLANAR_CURVE_PAIR"); +static TCollection_AsciiString Reco_PlanarCurvePairRange("PLANAR_CURVE_PAIR_RANGE"); +static TCollection_AsciiString Reco_PlanarPair("PLANAR_PAIR"); +static TCollection_AsciiString Reco_PlanarPairValue("PLANAR_PAIR_VALUE"); +static TCollection_AsciiString Reco_PlanarPairWithRange("PLANAR_PAIR_WITH_RANGE"); +static TCollection_AsciiString Reco_PointOnPlanarCurvePair("POINT_ON_PLANAR_CURVE_PAIR"); +static TCollection_AsciiString Reco_PointOnPlanarCurvePairValue("POINT_ON_PLANAR_CURVE_PAIR_VALUE"); +static TCollection_AsciiString Reco_PointOnPlanarCurvePairWithRange("POINT_ON_PLANAR_CURVE_PAIR_WITH_RANGE"); +static TCollection_AsciiString Reco_PointOnSurfacePair("POINT_ON_SURFACE_PAIR"); +static TCollection_AsciiString Reco_PointOnSurfacePairValue("POINT_ON_SURFACE_PAIR_VALUE"); +static TCollection_AsciiString Reco_PointOnSurfacePairWithRange("POINT_ON_SURFACE_PAIR_WITH_RANGE"); +static TCollection_AsciiString Reco_PrismaticPair("PRISMATIC_PAIR"); +static TCollection_AsciiString Reco_PrismaticPairValue("PRISMATIC_PAIR_VALUE"); +static TCollection_AsciiString Reco_PrismaticPairWithRange("PRISMATIC_PAIR_WITH_RANGE"); +static TCollection_AsciiString Reco_ProductDefinitionKinematics("PRODUCT_DEFINITION_KINEMATICS"); +static TCollection_AsciiString Reco_ProductDefinitionRelationshipKinematics("PRODUCT_DEFINITION_RELATIONSHIP_KINEMATICS"); +static TCollection_AsciiString Reco_RackAndPinionPair("RACK_AND_PINION_PAIR"); +static TCollection_AsciiString Reco_RackAndPinionPairValue("RACK_AND_PINION_PAIR_VALUE"); +static TCollection_AsciiString Reco_RackAndPinionPairWithRange("RACK_AND_PINION_PAIR_WITH_RANGE"); +static TCollection_AsciiString Reco_RevolutePair("REVOLUTE_PAIR"); +static TCollection_AsciiString Reco_RevolutePairValue("REVOLUTE_PAIR_VALUE"); +static TCollection_AsciiString Reco_RevolutePairWithRange("REVOLUTE_PAIR_WITH_RANGE"); +static TCollection_AsciiString Reco_RigidLinkRepresentation("RIGID_LINK_REPRESENTATION"); +static TCollection_AsciiString Reco_RollingCurvePair("ROLLING_CURVE_PAIR"); +static TCollection_AsciiString Reco_RollingCurvePairValue("ROLLING_CURVE_PAIR_VALUE"); +static TCollection_AsciiString Reco_RollingSurfacePair("ROLLING_SURFACE_PAIR"); +static TCollection_AsciiString Reco_RollingSurfacePairValue("ROLLING_SURFACE_PAIR_VALUE"); +static TCollection_AsciiString Reco_ScrewPair("SCREW_PAIR"); +static TCollection_AsciiString Reco_ScrewPairValue("SCREW_PAIR_VALUE"); +static TCollection_AsciiString Reco_ScrewPairWithRange("SCREW_PAIR_WITH_RANGE"); +static TCollection_AsciiString Reco_SlidingCurvePair("SLIDING_CURVE_PAIR"); +static TCollection_AsciiString Reco_SlidingCurvePairValue("SLIDING_CURVE_PAIR_VALUE"); +static TCollection_AsciiString Reco_SlidingSurfacePair("SLIDING_SURFACE_PAIR"); +static TCollection_AsciiString Reco_SlidingSurfacePairValue("SLIDING_SURFACE_PAIR_VALUE"); +static TCollection_AsciiString Reco_SphericalPair("SPHERICAL_PAIR"); +static TCollection_AsciiString Reco_SphericalPairValue("SPHERICAL_PAIR_VALUE"); +static TCollection_AsciiString Reco_SphericalPairWithPin("SPHERICAL_PAIR_WITH_PIN"); +static TCollection_AsciiString Reco_SphericalPairWithPinAndRange("SPHERICAL_PAIR_WITH_PIN_AND_RANGE"); +static TCollection_AsciiString Reco_SphericalPairWithRange("SPHERICAL_PAIR_WITH_RANGE"); +static TCollection_AsciiString Reco_SurfacePairWithRange("SURFACE_PAIR_WITH_RANGE"); +static TCollection_AsciiString Reco_UnconstrainedPair("UNCONSTRAINED_PAIR"); +static TCollection_AsciiString Reco_UnconstrainedPairValue("UNCONSTRAINED_PAIR_VALUE"); +static TCollection_AsciiString Reco_UniversalPair("UNIVERSAL_PAIR"); +static TCollection_AsciiString Reco_UniversalPairValue("UNIVERSAL_PAIR_VALUE"); +static TCollection_AsciiString Reco_UniversalPairWithRange("UNIVERSAL_PAIR_WITH_RANGE"); +static TCollection_AsciiString Reco_KinematicPair("KINEMATIC_PAIR"); +static TCollection_AsciiString Reco_MechanismStateRepresentation("MECHANISM_STATE_REPRESENTATION"); + // -- Definition of the libraries -- static NCollection_DataMap typenums; @@ -2722,6 +2958,85 @@ RWStepAP214_ReadWriteModule::RWStepAP214_ReadWriteModule () typenums.Bind (Reco_SurfaceStyleRendering, 722); typenums.Bind (Reco_SurfaceStyleRenderingWithProperties, 723); + typenums.Bind(Reco_RepresentationContextReference, 724); + typenums.Bind(Reco_RepresentationReference, 725); + typenums.Bind(Reco_SuParameters, 726); + typenums.Bind(Reco_RotationAboutDirection, 727); + typenums.Bind(Reco_KinematicJoint, 728); + typenums.Bind(Reco_ActuatedKinematicPair, 729); + typenums.Bind(Reco_ContextDependentKinematicLinkRepresentation, 730); + typenums.Bind(Reco_CylindricalPair, 731); + typenums.Bind(Reco_CylindricalPairValue, 732); + typenums.Bind(Reco_CylindricalPairWithRange, 733); + typenums.Bind(Reco_FullyConstrainedPair, 734); + typenums.Bind(Reco_GearPair, 735); + typenums.Bind(Reco_GearPairValue, 736); + typenums.Bind(Reco_GearPairWithRange, 737); + typenums.Bind(Reco_HomokineticPair, 738); + typenums.Bind(Reco_KinematicLink, 739); + typenums.Bind(Reco_KinematicLinkRepresentationAssociation, 740); + typenums.Bind(Reco_KinematicPropertyMechanismRepresentation, 741); + typenums.Bind(Reco_KinematicTopologyStructure, 742); + typenums.Bind(Reco_LowOrderKinematicPair, 743); + typenums.Bind(Reco_LowOrderKinematicPairValue, 744); + typenums.Bind(Reco_LowOrderKinematicPairWithRange, 745); + typenums.Bind(Reco_MechanismRepresentation, 746); + typenums.Bind(Reco_OrientedJoint, 747); + typenums.Bind(Reco_PlanarCurvePair, 748); + typenums.Bind(Reco_PlanarCurvePairRange, 749); + typenums.Bind(Reco_PlanarPair, 750); + typenums.Bind(Reco_PlanarPairValue, 751); + typenums.Bind(Reco_PlanarPairWithRange, 752); + typenums.Bind(Reco_PointOnPlanarCurvePair, 753); + typenums.Bind(Reco_PointOnPlanarCurvePairValue, 754); + typenums.Bind(Reco_PointOnPlanarCurvePairWithRange, 755); + typenums.Bind(Reco_PointOnSurfacePair, 756); + typenums.Bind(Reco_PointOnSurfacePairValue, 757); + typenums.Bind(Reco_PointOnSurfacePairWithRange, 758); + typenums.Bind(Reco_PrismaticPair, 759); + typenums.Bind(Reco_PrismaticPairValue, 760); + typenums.Bind(Reco_PrismaticPairWithRange, 761); + typenums.Bind(Reco_ProductDefinitionKinematics, 762); + typenums.Bind(Reco_ProductDefinitionRelationshipKinematics, 763); + typenums.Bind(Reco_RackAndPinionPair, 764); + typenums.Bind(Reco_RackAndPinionPairValue, 765); + typenums.Bind(Reco_RackAndPinionPairWithRange, 766); + typenums.Bind(Reco_RevolutePair, 767); + typenums.Bind(Reco_RevolutePairValue, 768); + typenums.Bind(Reco_RevolutePairWithRange, 769); + typenums.Bind(Reco_RollingCurvePair, 770); + typenums.Bind(Reco_RollingCurvePairValue, 771); + typenums.Bind(Reco_RollingSurfacePair, 772); + typenums.Bind(Reco_RollingSurfacePairValue, 773); + typenums.Bind(Reco_ScrewPair, 774); + typenums.Bind(Reco_ScrewPairValue, 775); + typenums.Bind(Reco_ScrewPairWithRange, 776); + typenums.Bind(Reco_SlidingCurvePair, 777); + typenums.Bind(Reco_SlidingCurvePairValue, 778); + typenums.Bind(Reco_SlidingSurfacePair, 779); + typenums.Bind(Reco_SlidingSurfacePairValue, 780); + typenums.Bind(Reco_SphericalPair, 781); + typenums.Bind(Reco_SphericalPairValue, 782); + typenums.Bind(Reco_SphericalPairWithPin, 783); + typenums.Bind(Reco_SphericalPairWithPinAndRange, 784); + typenums.Bind(Reco_SphericalPairWithRange, 785); + typenums.Bind(Reco_SurfacePairWithRange, 786); + typenums.Bind(Reco_UnconstrainedPair, 787); + typenums.Bind(Reco_UnconstrainedPairValue, 788); + typenums.Bind(Reco_UniversalPair, 789); + typenums.Bind(Reco_UniversalPairValue, 790); + typenums.Bind(Reco_UniversalPairWithRange, 791); + typenums.Bind(Reco_PairRepresentationRelationship, 792); + typenums.Bind(Reco_RigidLinkRepresentation, 793); + typenums.Bind(Reco_KinematicTopologyDirectedStructure, 794); + typenums.Bind(Reco_KinematicTopologyNetworkStructure, 795); + typenums.Bind(Reco_LinearFlexibleAndPinionPair, 796); + typenums.Bind(Reco_LinearFlexibleAndPlanarCurvePair, 797); + typenums.Bind(Reco_LinearFlexibleLinkRepresentation, 798); + typenums.Bind(Reco_KinematicPair, 799); + typenums.Bind(Reco_MechanismStateRepresentation, 801); + + // SHORT NAMES // NB : la liste est celle de AP203 // Directement exploite pour les types simples @@ -3337,7 +3652,30 @@ Standard_Integer RWStepAP214_ReadWriteModule::CaseStep } } - if (NbComp == 7) { + if (NbComp == 8) + { + if ((types(1).IsEqual(StepType(729))) && + (types(2).IsEqual(StepType(144))) && + (types(3).IsEqual(StepType(354))) && + (types(4).IsEqual(StepType(799))) && + (types(5).IsEqual(StepType(743))) && + (((types(6).IsEqual(StepType(759))) && + (types(7).IsEqual(StepType(761)))) || + ((types(6).IsEqual(StepType(731))) && + (types(7).IsEqual(StepType(733)))) || + ((types(6).IsEqual(StepType(767))) && + (types(7).IsEqual(StepType(769)))) || + ((types(6).IsEqual(StepType(789))) && + (types(7).IsEqual(StepType(791)))) || + ((types(6).IsEqual(StepType(781))) && + (types(7).IsEqual(StepType(785)))) || + ((types(6).IsEqual(StepType(783))) && + (types(7).IsEqual(StepType(784))))) && + (types(8).IsEqual(StepType(247)))) { + return 800; + } + } + else if (NbComp == 7) { if ((types(1).IsEqual(StepType(48))) && (types(2).IsEqual(StepType(38))) && (types(3).IsEqual(StepType(84))) && @@ -4581,6 +4919,84 @@ const TCollection_AsciiString& RWStepAP214_ReadWriteModule::StepType case 722 : return Reco_SurfaceStyleRendering; case 723 : return Reco_SurfaceStyleRenderingWithProperties; + case 724: return Reco_RepresentationContextReference; + case 725: return Reco_RepresentationReference; + case 726: return Reco_SuParameters; + case 727: return Reco_RotationAboutDirection; + case 728: return Reco_KinematicJoint; + case 729: return Reco_ActuatedKinematicPair; + case 730: return Reco_ContextDependentKinematicLinkRepresentation; + case 731: return Reco_CylindricalPair; + case 732: return Reco_CylindricalPairValue; + case 733: return Reco_CylindricalPairWithRange; + case 734: return Reco_FullyConstrainedPair; + case 735: return Reco_GearPair; + case 736: return Reco_GearPairValue; + case 737: return Reco_GearPairWithRange; + case 738: return Reco_HomokineticPair; + case 739: return Reco_KinematicLink; + case 740: return Reco_KinematicLinkRepresentationAssociation; + case 741: return Reco_KinematicPropertyMechanismRepresentation; + case 742: return Reco_KinematicTopologyStructure; + case 743: return Reco_LowOrderKinematicPair; + case 744: return Reco_LowOrderKinematicPairValue; + case 745: return Reco_LowOrderKinematicPairWithRange; + case 746: return Reco_MechanismRepresentation; + case 747: return Reco_OrientedJoint; + case 748: return Reco_PlanarCurvePair; + case 749: return Reco_PlanarCurvePairRange; + case 750: return Reco_PlanarPair; + case 751: return Reco_PlanarPairValue; + case 752: return Reco_PlanarPairWithRange; + case 753: return Reco_PointOnPlanarCurvePair; + case 754: return Reco_PointOnPlanarCurvePairValue; + case 755: return Reco_PointOnPlanarCurvePairWithRange; + case 756: return Reco_PointOnSurfacePair; + case 757: return Reco_PointOnSurfacePairValue; + case 758: return Reco_PointOnSurfacePairWithRange; + case 759: return Reco_PrismaticPair; + case 760: return Reco_PrismaticPairValue; + case 761: return Reco_PrismaticPairWithRange; + case 762: return Reco_ProductDefinitionKinematics; + case 763: return Reco_ProductDefinitionRelationshipKinematics; + case 764: return Reco_RackAndPinionPair; + case 765: return Reco_RackAndPinionPairValue; + case 766: return Reco_RackAndPinionPairWithRange; + case 767: return Reco_RevolutePair; + case 768: return Reco_RevolutePairValue; + case 769: return Reco_RevolutePairWithRange; + case 770: return Reco_RollingCurvePair; + case 771: return Reco_RollingCurvePairValue; + case 772: return Reco_RollingSurfacePair; + case 773: return Reco_RollingSurfacePairValue; + case 774: return Reco_ScrewPair; + case 775: return Reco_ScrewPairValue; + case 776: return Reco_ScrewPairWithRange; + case 777: return Reco_SlidingCurvePair; + case 778: return Reco_SlidingCurvePairValue; + case 779: return Reco_SlidingSurfacePair; + case 780: return Reco_SlidingSurfacePairValue; + case 781: return Reco_SphericalPair; + case 782: return Reco_SphericalPairValue; + case 783: return Reco_SphericalPairWithPin; + case 784: return Reco_SphericalPairWithPinAndRange; + case 785: return Reco_SphericalPairWithRange; + case 786: return Reco_SurfacePairWithRange; + case 787: return Reco_UnconstrainedPair; + case 788: return Reco_UnconstrainedPairValue; + case 789: return Reco_UniversalPair; + case 790: return Reco_UniversalPairValue; + case 791: return Reco_UniversalPairWithRange; + case 792: return Reco_PairRepresentationRelationship; + case 793: return Reco_RigidLinkRepresentation; + case 794: return Reco_KinematicTopologyDirectedStructure; + case 795: return Reco_KinematicTopologyNetworkStructure; + case 796: return Reco_LinearFlexibleAndPinionPair; + case 797: return Reco_LinearFlexibleAndPlanarCurvePair; + case 798: return Reco_LinearFlexibleLinkRepresentation; + case 799: return Reco_KinematicPair; + case 801: return Reco_MechanismStateRepresentation; + default : return PasReco; } } @@ -4864,7 +5280,6 @@ Standard_Boolean RWStepAP214_ReadWriteModule::ComplexType(const Standard_Integer types.Append (StepType(625)); types.Append (StepType(677)); break; - default : return Standard_False; case 698: types.Append (StepType(671)); types.Append (StepType(470)); @@ -4902,6 +5317,17 @@ Standard_Boolean RWStepAP214_ReadWriteModule::ComplexType(const Standard_Integer types.Append(StepType(247)); types.Append(StepType(270)); break; + case 800: + types.Append(StepType(729)); + types.Append(StepType(144)); + types.Append(StepType(354)); + types.Append(StepType(799)); + types.Append(StepType(743)); + types.Append(StepType(757)); + types.Append(StepType(759)); + types.Append(StepType(247)); + break; + default: return Standard_False; } return Standard_True; } @@ -9507,6 +9933,545 @@ void RWStepAP214_ReadWriteModule::ReadStep(const Standard_Integer CN, RWStepVisual_RWSurfaceStyleRenderingWithProperties tool; tool.ReadStep(data, num, ach, anent); } + break; + case 724: + { + DeclareAndCast(StepRepr_RepresentationContextReference, anent, ent); + RWStepRepr_RWRepresentationContextReference tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 725: + { + DeclareAndCast(StepRepr_RepresentationReference, anent, ent); + RWStepRepr_RWRepresentationReference tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 726: + { + DeclareAndCast(StepGeom_SuParameters, anent, ent); + RWStepGeom_RWSuParameters tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 727: + { + DeclareAndCast(StepKinematics_RotationAboutDirection, anent, ent); + RWStepKinematics_RWRotationAboutDirection tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 728: + { + DeclareAndCast(StepKinematics_KinematicJoint, anent, ent); + RWStepKinematics_RWKinematicJoint tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 729: + { + DeclareAndCast(StepKinematics_ActuatedKinematicPair, anent, ent); + RWStepKinematics_RWActuatedKinematicPair tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 730: + { + DeclareAndCast(StepKinematics_ContextDependentKinematicLinkRepresentation, anent, ent); + RWStepKinematics_RWContextDependentKinematicLinkRepresentation tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 731: + { + DeclareAndCast(StepKinematics_CylindricalPair, anent, ent); + RWStepKinematics_RWCylindricalPair tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 732: + { + DeclareAndCast(StepKinematics_CylindricalPairValue, anent, ent); + RWStepKinematics_RWCylindricalPairValue tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 733: + { + DeclareAndCast(StepKinematics_CylindricalPairWithRange, anent, ent); + RWStepKinematics_RWCylindricalPairWithRange tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 734: + { + DeclareAndCast(StepKinematics_FullyConstrainedPair, anent, ent); + RWStepKinematics_RWFullyConstrainedPair tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 735: + { + DeclareAndCast(StepKinematics_GearPair, anent, ent); + RWStepKinematics_RWGearPair tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 736: + { + DeclareAndCast(StepKinematics_GearPairValue, anent, ent); + RWStepKinematics_RWGearPairValue tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 737: + { + DeclareAndCast(StepKinematics_GearPairWithRange, anent, ent); + RWStepKinematics_RWGearPairWithRange tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 738: + { + DeclareAndCast(StepKinematics_HomokineticPair, anent, ent); + RWStepKinematics_RWHomokineticPair tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 739: + { + DeclareAndCast(StepKinematics_KinematicLink, anent, ent); + RWStepKinematics_RWKinematicLink tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 740: + { + DeclareAndCast(StepKinematics_KinematicLinkRepresentationAssociation, anent, ent); + RWStepKinematics_RWKinematicLinkRepresentationAssociation tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 741: + { + DeclareAndCast(StepKinematics_KinematicPropertyMechanismRepresentation, anent, ent); + RWStepKinematics_RWKinematicPropertyMechanismRepresentation tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 742: + { + DeclareAndCast(StepKinematics_KinematicTopologyStructure, anent, ent); + RWStepKinematics_RWKinematicTopologyStructure tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 743: + { + DeclareAndCast(StepKinematics_LowOrderKinematicPair, anent, ent); + RWStepKinematics_RWLowOrderKinematicPair tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 744: + { + DeclareAndCast(StepKinematics_LowOrderKinematicPairValue, anent, ent); + RWStepKinematics_RWLowOrderKinematicPairValue tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 745: + { + DeclareAndCast(StepKinematics_LowOrderKinematicPairWithRange, anent, ent); + RWStepKinematics_RWLowOrderKinematicPairWithRange tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 746: + { + DeclareAndCast(StepKinematics_MechanismRepresentation, anent, ent); + RWStepKinematics_RWMechanismRepresentation tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 747: + { + DeclareAndCast(StepKinematics_OrientedJoint, anent, ent); + RWStepKinematics_RWOrientedJoint tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 748: + { + DeclareAndCast(StepKinematics_PlanarCurvePair, anent, ent); + RWStepKinematics_RWPlanarCurvePair tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 749: + { + DeclareAndCast(StepKinematics_PlanarCurvePairRange, anent, ent); + RWStepKinematics_RWPlanarCurvePairRange tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 750: + { + DeclareAndCast(StepKinematics_PlanarPair, anent, ent); + RWStepKinematics_RWPlanarPair tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 751: + { + DeclareAndCast(StepKinematics_PlanarPairValue, anent, ent); + RWStepKinematics_RWPlanarPairValue tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 752: + { + DeclareAndCast(StepKinematics_PlanarPairWithRange, anent, ent); + RWStepKinematics_RWPlanarPairWithRange tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 753: + { + DeclareAndCast(StepKinematics_PointOnPlanarCurvePair, anent, ent); + RWStepKinematics_RWPointOnPlanarCurvePair tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 754: + { + DeclareAndCast(StepKinematics_PointOnPlanarCurvePairValue, anent, ent); + RWStepKinematics_RWPointOnPlanarCurvePairValue tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 755: + { + DeclareAndCast(StepKinematics_PointOnPlanarCurvePairWithRange, anent, ent); + RWStepKinematics_RWPointOnPlanarCurvePairWithRange tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 756: + { + DeclareAndCast(StepKinematics_PointOnSurfacePair, anent, ent); + RWStepKinematics_RWPointOnSurfacePair tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 757: + { + DeclareAndCast(StepKinematics_PointOnSurfacePairValue, anent, ent); + RWStepKinematics_RWPointOnSurfacePairValue tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 758: + { + DeclareAndCast(StepKinematics_PointOnSurfacePairWithRange, anent, ent); + RWStepKinematics_RWPointOnSurfacePairWithRange tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 759: + { + DeclareAndCast(StepKinematics_PrismaticPair, anent, ent); + RWStepKinematics_RWPrismaticPair tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 760: + { + DeclareAndCast(StepKinematics_PrismaticPairValue, anent, ent); + RWStepKinematics_RWPrismaticPairValue tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 761: + { + DeclareAndCast(StepKinematics_PrismaticPairWithRange, anent, ent); + RWStepKinematics_RWPrismaticPairWithRange tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 762: + { + DeclareAndCast(StepKinematics_ProductDefinitionKinematics, anent, ent); + RWStepKinematics_RWProductDefinitionKinematics tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 763: + { + DeclareAndCast(StepKinematics_ProductDefinitionRelationshipKinematics, anent, ent); + RWStepKinematics_RWProductDefinitionRelationshipKinematics tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 764: + { + DeclareAndCast(StepKinematics_RackAndPinionPair, anent, ent); + RWStepKinematics_RWRackAndPinionPair tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 765: + { + DeclareAndCast(StepKinematics_RackAndPinionPairValue, anent, ent); + RWStepKinematics_RWRackAndPinionPairValue tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 766: + { + DeclareAndCast(StepKinematics_RackAndPinionPairWithRange, anent, ent); + RWStepKinematics_RWRackAndPinionPairWithRange tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 767: + { + DeclareAndCast(StepKinematics_RevolutePair, anent, ent); + RWStepKinematics_RWRevolutePair tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 768: + { + DeclareAndCast(StepKinematics_RevolutePairValue, anent, ent); + RWStepKinematics_RWRevolutePairValue tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 769: + { + DeclareAndCast(StepKinematics_RevolutePairWithRange, anent, ent); + RWStepKinematics_RWRevolutePairWithRange tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 770: + { + DeclareAndCast(StepKinematics_RollingCurvePair, anent, ent); + RWStepKinematics_RWRollingCurvePair tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 771: + { + DeclareAndCast(StepKinematics_RollingCurvePairValue, anent, ent); + RWStepKinematics_RWRollingCurvePairValue tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 772: + { + DeclareAndCast(StepKinematics_RollingSurfacePair, anent, ent); + RWStepKinematics_RWRollingSurfacePair tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 773: + { + DeclareAndCast(StepKinematics_RollingSurfacePairValue, anent, ent); + RWStepKinematics_RWRollingSurfacePairValue tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 774: + { + DeclareAndCast(StepKinematics_ScrewPair, anent, ent); + RWStepKinematics_RWScrewPair tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 775: + { + DeclareAndCast(StepKinematics_ScrewPairValue, anent, ent); + RWStepKinematics_RWScrewPairValue tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 776: + { + DeclareAndCast(StepKinematics_ScrewPairWithRange, anent, ent); + RWStepKinematics_RWScrewPairWithRange tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 777: + { + DeclareAndCast(StepKinematics_SlidingCurvePair, anent, ent); + RWStepKinematics_RWSlidingCurvePair tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 778: + { + DeclareAndCast(StepKinematics_SlidingCurvePairValue, anent, ent); + RWStepKinematics_RWSlidingCurvePairValue tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 779: + { + DeclareAndCast(StepKinematics_SlidingSurfacePair, anent, ent); + RWStepKinematics_RWSlidingSurfacePair tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 780: + { + DeclareAndCast(StepKinematics_SlidingSurfacePairValue, anent, ent); + RWStepKinematics_RWSlidingSurfacePairValue tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 781: + { + DeclareAndCast(StepKinematics_SphericalPair, anent, ent); + RWStepKinematics_RWSphericalPair tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 782: + { + DeclareAndCast(StepKinematics_SphericalPairValue, anent, ent); + RWStepKinematics_RWSphericalPairValue tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 783: + { + DeclareAndCast(StepKinematics_SphericalPairWithPin, anent, ent); + RWStepKinematics_RWSphericalPairWithPin tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 784: + { + DeclareAndCast(StepKinematics_SphericalPairWithPinAndRange, anent, ent); + RWStepKinematics_RWSphericalPairWithPinAndRange tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 785: + { + DeclareAndCast(StepKinematics_SphericalPairWithRange, anent, ent); + RWStepKinematics_RWSphericalPairWithRange tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 786: + { + DeclareAndCast(StepKinematics_SurfacePairWithRange, anent, ent); + RWStepKinematics_RWSurfacePairWithRange tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 787: + { + DeclareAndCast(StepKinematics_UnconstrainedPair, anent, ent); + RWStepKinematics_RWUnconstrainedPair tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 788: + { + DeclareAndCast(StepKinematics_UnconstrainedPairValue, anent, ent); + RWStepKinematics_RWUnconstrainedPairValue tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 789: + { + DeclareAndCast(StepKinematics_UniversalPair, anent, ent); + RWStepKinematics_RWUniversalPair tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 790: + { + DeclareAndCast(StepKinematics_UniversalPairValue, anent, ent); + RWStepKinematics_RWUniversalPairValue tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 791: + { + DeclareAndCast(StepKinematics_UniversalPairWithRange, anent, ent); + RWStepKinematics_RWUniversalPairWithRange tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 792: + { + DeclareAndCast(StepKinematics_PairRepresentationRelationship, anent, ent); + RWStepKinematics_RWPairRepresentationRelationship tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 793: + { + DeclareAndCast(StepKinematics_RigidLinkRepresentation, anent, ent); + RWStepKinematics_RWRigidLinkRepresentation tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 794: + { + DeclareAndCast(StepKinematics_KinematicTopologyDirectedStructure, anent, ent); + RWStepKinematics_RWKinematicTopologyDirectedStructure tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 795: + { + DeclareAndCast(StepKinematics_KinematicTopologyNetworkStructure, anent, ent); + RWStepKinematics_RWKinematicTopologyNetworkStructure tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 796: + { + DeclareAndCast(StepKinematics_LinearFlexibleAndPinionPair, anent, ent); + RWStepKinematics_RWLinearFlexibleAndPinionPair tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 797: + { + DeclareAndCast(StepKinematics_LinearFlexibleAndPlanarCurvePair, anent, ent); + RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 798: + { + DeclareAndCast(StepKinematics_LinearFlexibleLinkRepresentation, anent, ent); + RWStepKinematics_RWLinearFlexibleLinkRepresentation tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 800: + { + DeclareAndCast(StepKinematics_ActuatedKinPairAndOrderKinPair, anent, ent); + RWStepKinematics_RWActuatedKinPairAndOrderKinPair tool; + tool.ReadStep(data, num, ach, anent); + } + break; + case 801: + { + DeclareAndCast(StepKinematics_MechanismStateRepresentation, anent, ent); + RWStepKinematics_RWMechanismStateRepresentation tool; + tool.ReadStep(data, num, ach, anent); + } break; default: @@ -14392,6 +15357,546 @@ void RWStepAP214_ReadWriteModule::WriteStep(const Standard_Integer CN, tool.WriteStep(SW, anent); } break; + case 724: + { + DeclareAndCast(StepRepr_RepresentationContextReference, anent, ent); + RWStepRepr_RWRepresentationContextReference tool; + tool.WriteStep(SW, anent); + } + break; + case 725: + { + DeclareAndCast(StepRepr_RepresentationReference, anent, ent); + RWStepRepr_RWRepresentationReference tool; + tool.WriteStep(SW, anent); + } + break; + case 726: + { + DeclareAndCast(StepGeom_SuParameters, anent, ent); + RWStepGeom_RWSuParameters tool; + tool.WriteStep(SW, anent); + } + break; + case 727: + { + DeclareAndCast(StepKinematics_RotationAboutDirection, anent, ent); + RWStepKinematics_RWRotationAboutDirection tool; + tool.WriteStep(SW, anent); + } + break; + case 728: + { + DeclareAndCast(StepKinematics_KinematicJoint, anent, ent); + RWStepKinematics_RWKinematicJoint tool; + tool.WriteStep(SW, anent); + } + break; + case 729: + { + DeclareAndCast(StepKinematics_ActuatedKinematicPair, anent, ent); + RWStepKinematics_RWActuatedKinematicPair tool; + tool.WriteStep(SW, anent); + } + break; + case 730: + { + DeclareAndCast(StepKinematics_ContextDependentKinematicLinkRepresentation, anent, ent); + RWStepKinematics_RWContextDependentKinematicLinkRepresentation tool; + tool.WriteStep(SW, anent); + } + break; + case 731: + { + DeclareAndCast(StepKinematics_CylindricalPair, anent, ent); + RWStepKinematics_RWCylindricalPair tool; + tool.WriteStep(SW, anent); + } + break; + case 732: + { + DeclareAndCast(StepKinematics_CylindricalPairValue, anent, ent); + RWStepKinematics_RWCylindricalPairValue tool; + tool.WriteStep(SW, anent); + } + break; + case 733: + { + DeclareAndCast(StepKinematics_CylindricalPairWithRange, anent, ent); + RWStepKinematics_RWCylindricalPairWithRange tool; + tool.WriteStep(SW, anent); + } + break; + case 734: + { + DeclareAndCast(StepKinematics_FullyConstrainedPair, anent, ent); + RWStepKinematics_RWFullyConstrainedPair tool; + tool.WriteStep(SW, anent); + } + break; + case 735: + { + DeclareAndCast(StepKinematics_GearPair, anent, ent); + RWStepKinematics_RWGearPair tool; + tool.WriteStep(SW, anent); + } + break; + case 736: + { + DeclareAndCast(StepKinematics_GearPairValue, anent, ent); + RWStepKinematics_RWGearPairValue tool; + tool.WriteStep(SW, anent); + } + break; + case 737: + { + DeclareAndCast(StepKinematics_GearPairWithRange, anent, ent); + RWStepKinematics_RWGearPairWithRange tool; + tool.WriteStep(SW, anent); + } + break; + case 738: + { + DeclareAndCast(StepKinematics_HomokineticPair, anent, ent); + RWStepKinematics_RWHomokineticPair tool; + tool.WriteStep(SW, anent); + } + break; + case 739: + { + DeclareAndCast(StepKinematics_KinematicLink, anent, ent); + RWStepKinematics_RWKinematicLink tool; + tool.WriteStep(SW, anent); + } + break; + case 740: + { + DeclareAndCast(StepKinematics_KinematicLinkRepresentationAssociation, anent, ent); + RWStepKinematics_RWKinematicLinkRepresentationAssociation tool; + tool.WriteStep(SW, anent); + } + break; + case 741: + { + DeclareAndCast(StepKinematics_KinematicPropertyMechanismRepresentation, anent, ent); + RWStepKinematics_RWKinematicPropertyMechanismRepresentation tool; + tool.WriteStep(SW, anent); + } + break; + case 742: + { + DeclareAndCast(StepKinematics_KinematicTopologyStructure, anent, ent); + RWStepKinematics_RWKinematicTopologyStructure tool; + tool.WriteStep(SW, anent); + } + break; + case 743: + { + DeclareAndCast(StepKinematics_LowOrderKinematicPair, anent, ent); + RWStepKinematics_RWLowOrderKinematicPair tool; + tool.WriteStep(SW, anent); + } + break; + case 744: + { + DeclareAndCast(StepKinematics_LowOrderKinematicPairValue, anent, ent); + RWStepKinematics_RWLowOrderKinematicPairValue tool; + tool.WriteStep(SW, anent); + } + break; + case 745: + { + DeclareAndCast(StepKinematics_LowOrderKinematicPairWithRange, anent, ent); + RWStepKinematics_RWLowOrderKinematicPairWithRange tool; + tool.WriteStep(SW, anent); + } + break; + case 746: + { + DeclareAndCast(StepKinematics_MechanismRepresentation, anent, ent); + RWStepKinematics_RWMechanismRepresentation tool; + tool.WriteStep(SW, anent); + } + break; + case 747: + { + DeclareAndCast(StepKinematics_OrientedJoint, anent, ent); + RWStepKinematics_RWOrientedJoint tool; + tool.WriteStep(SW, anent); + } + break; + case 748: + { + DeclareAndCast(StepKinematics_PlanarCurvePair, anent, ent); + RWStepKinematics_RWPlanarCurvePair tool; + tool.WriteStep(SW, anent); + } + break; + case 749: + { + DeclareAndCast(StepKinematics_PlanarCurvePairRange, anent, ent); + RWStepKinematics_RWPlanarCurvePairRange tool; + tool.WriteStep(SW, anent); + } + break; + case 750: + { + DeclareAndCast(StepKinematics_PlanarPair, anent, ent); + RWStepKinematics_RWPlanarPair tool; + tool.WriteStep(SW, anent); + } + break; + case 751: + { + DeclareAndCast(StepKinematics_PlanarPairValue, anent, ent); + RWStepKinematics_RWPlanarPairValue tool; + tool.WriteStep(SW, anent); + } + break; + case 752: + { + DeclareAndCast(StepKinematics_PlanarPairWithRange, anent, ent); + RWStepKinematics_RWPlanarPairWithRange tool; + tool.WriteStep(SW, anent); + } + break; + case 753: + { + DeclareAndCast(StepKinematics_PointOnPlanarCurvePair, anent, ent); + RWStepKinematics_RWPointOnPlanarCurvePair tool; + tool.WriteStep(SW, anent); + } + break; + case 754: + { + DeclareAndCast(StepKinematics_PointOnPlanarCurvePairValue, anent, ent); + RWStepKinematics_RWPointOnPlanarCurvePairValue tool; + tool.WriteStep(SW, anent); + } + break; + case 755: + { + DeclareAndCast(StepKinematics_PointOnPlanarCurvePairWithRange, anent, ent); + RWStepKinematics_RWPointOnPlanarCurvePairWithRange tool; + tool.WriteStep(SW, anent); + } + break; + case 756: + { + DeclareAndCast(StepKinematics_PointOnSurfacePair, anent, ent); + RWStepKinematics_RWPointOnSurfacePair tool; + tool.WriteStep(SW, anent); + } + break; + case 757: + { + DeclareAndCast(StepKinematics_PointOnSurfacePairValue, anent, ent); + RWStepKinematics_RWPointOnSurfacePairValue tool; + tool.WriteStep(SW, anent); + } + break; + case 758: + { + DeclareAndCast(StepKinematics_PointOnSurfacePairWithRange, anent, ent); + RWStepKinematics_RWPointOnSurfacePairWithRange tool; + tool.WriteStep(SW, anent); + } + break; + case 759: + { + DeclareAndCast(StepKinematics_PrismaticPair, anent, ent); + RWStepKinematics_RWPrismaticPair tool; + tool.WriteStep(SW, anent); + } + break; + case 760: + { + DeclareAndCast(StepKinematics_PrismaticPairValue, anent, ent); + RWStepKinematics_RWPrismaticPairValue tool; + tool.WriteStep(SW, anent); + } + break; + case 761: + { + DeclareAndCast(StepKinematics_PrismaticPairWithRange, anent, ent); + RWStepKinematics_RWPrismaticPairWithRange tool; + tool.WriteStep(SW, anent); + } + break; + case 762: + { + DeclareAndCast(StepKinematics_ProductDefinitionKinematics, anent, ent); + RWStepKinematics_RWProductDefinitionKinematics tool; + tool.WriteStep(SW, anent); + } + break; + case 763: + { + DeclareAndCast(StepKinematics_ProductDefinitionRelationshipKinematics, anent, ent); + RWStepKinematics_RWProductDefinitionRelationshipKinematics tool; + tool.WriteStep(SW, anent); + } + break; + case 764: + { + DeclareAndCast(StepKinematics_RackAndPinionPair, anent, ent); + RWStepKinematics_RWRackAndPinionPair tool; + tool.WriteStep(SW, anent); + } + break; + case 765: + { + DeclareAndCast(StepKinematics_RackAndPinionPairValue, anent, ent); + RWStepKinematics_RWRackAndPinionPairValue tool; + tool.WriteStep(SW, anent); + } + break; + case 766: + { + DeclareAndCast(StepKinematics_RackAndPinionPairWithRange, anent, ent); + RWStepKinematics_RWRackAndPinionPairWithRange tool; + tool.WriteStep(SW, anent); + } + break; + case 767: + { + DeclareAndCast(StepKinematics_RevolutePair, anent, ent); + RWStepKinematics_RWRevolutePair tool; + tool.WriteStep(SW, anent); + } + break; + case 768: + { + DeclareAndCast(StepKinematics_RevolutePairValue, anent, ent); + RWStepKinematics_RWRevolutePairValue tool; + tool.WriteStep(SW, anent); + } + break; + case 769: + { + DeclareAndCast(StepKinematics_RevolutePairWithRange, anent, ent); + RWStepKinematics_RWRevolutePairWithRange tool; + tool.WriteStep(SW, anent); + } + break; + case 770: + { + DeclareAndCast(StepKinematics_RollingCurvePair, anent, ent); + RWStepKinematics_RWRollingCurvePair tool; + tool.WriteStep(SW, anent); + } + break; + case 771: + { + DeclareAndCast(StepKinematics_RollingCurvePairValue, anent, ent); + RWStepKinematics_RWRollingCurvePairValue tool; + tool.WriteStep(SW, anent); + } + break; + case 772: + { + DeclareAndCast(StepKinematics_RollingSurfacePair, anent, ent); + RWStepKinematics_RWRollingSurfacePair tool; + tool.WriteStep(SW, anent); + } + break; + case 773: + { + DeclareAndCast(StepKinematics_RollingSurfacePairValue, anent, ent); + RWStepKinematics_RWRollingSurfacePairValue tool; + tool.WriteStep(SW, anent); + } + break; + case 774: + { + DeclareAndCast(StepKinematics_ScrewPair, anent, ent); + RWStepKinematics_RWScrewPair tool; + tool.WriteStep(SW, anent); + } + break; + case 775: + { + DeclareAndCast(StepKinematics_ScrewPairValue, anent, ent); + RWStepKinematics_RWScrewPairValue tool; + tool.WriteStep(SW, anent); + } + break; + case 776: + { + DeclareAndCast(StepKinematics_ScrewPairWithRange, anent, ent); + RWStepKinematics_RWScrewPairWithRange tool; + tool.WriteStep(SW, anent); + } + break; + case 777: + { + DeclareAndCast(StepKinematics_SlidingCurvePair, anent, ent); + RWStepKinematics_RWSlidingCurvePair tool; + tool.WriteStep(SW, anent); + } + break; + case 778: + { + DeclareAndCast(StepKinematics_SlidingCurvePairValue, anent, ent); + RWStepKinematics_RWSlidingCurvePairValue tool; + tool.WriteStep(SW, anent); + } + break; + case 779: + { + DeclareAndCast(StepKinematics_SlidingSurfacePair, anent, ent); + RWStepKinematics_RWSlidingSurfacePair tool; + tool.WriteStep(SW, anent); + } + break; + case 780: + { + DeclareAndCast(StepKinematics_SlidingSurfacePairValue, anent, ent); + RWStepKinematics_RWSlidingSurfacePairValue tool; + tool.WriteStep(SW, anent); + } + break; + case 781: + { + DeclareAndCast(StepKinematics_SphericalPair, anent, ent); + RWStepKinematics_RWSphericalPair tool; + tool.WriteStep(SW, anent); + } + break; + case 782: + { + DeclareAndCast(StepKinematics_SphericalPairValue, anent, ent); + RWStepKinematics_RWSphericalPairValue tool; + tool.WriteStep(SW, anent); + } + break; + case 783: + { + DeclareAndCast(StepKinematics_SphericalPairWithPin, anent, ent); + RWStepKinematics_RWSphericalPairWithPin tool; + tool.WriteStep(SW, anent); + } + break; + case 784: + { + DeclareAndCast(StepKinematics_SphericalPairWithPinAndRange, anent, ent); + RWStepKinematics_RWSphericalPairWithPinAndRange tool; + tool.WriteStep(SW, anent); + } + break; + case 785: + { + DeclareAndCast(StepKinematics_SphericalPairWithRange, anent, ent); + RWStepKinematics_RWSphericalPairWithRange tool; + tool.WriteStep(SW, anent); + } + break; + case 786: + { + DeclareAndCast(StepKinematics_SurfacePairWithRange, anent, ent); + RWStepKinematics_RWSurfacePairWithRange tool; + tool.WriteStep(SW, anent); + } + break; + case 787: + { + DeclareAndCast(StepKinematics_UnconstrainedPair, anent, ent); + RWStepKinematics_RWUnconstrainedPair tool; + tool.WriteStep(SW, anent); + } + break; + case 788: + { + DeclareAndCast(StepKinematics_UnconstrainedPairValue, anent, ent); + RWStepKinematics_RWUnconstrainedPairValue tool; + tool.WriteStep(SW, anent); + } + break; + case 789: + { + DeclareAndCast(StepKinematics_UniversalPair, anent, ent); + RWStepKinematics_RWUniversalPair tool; + tool.WriteStep(SW, anent); + } + break; + case 790: + { + DeclareAndCast(StepKinematics_UniversalPairValue, anent, ent); + RWStepKinematics_RWUniversalPairValue tool; + tool.WriteStep(SW, anent); + } + break; + case 791: + { + DeclareAndCast(StepKinematics_UniversalPairWithRange, anent, ent); + RWStepKinematics_RWUniversalPairWithRange tool; + tool.WriteStep(SW, anent); + } + break; + case 792: + { + DeclareAndCast(StepKinematics_PairRepresentationRelationship, anent, ent); + RWStepKinematics_RWPairRepresentationRelationship tool; + tool.WriteStep(SW, anent); + } + break; + case 793: + { + DeclareAndCast(StepKinematics_RigidLinkRepresentation, anent, ent); + RWStepKinematics_RWRigidLinkRepresentation tool; + tool.WriteStep(SW, anent); + } + break; + case 794: + { + DeclareAndCast(StepKinematics_KinematicTopologyDirectedStructure, anent, ent); + RWStepKinematics_RWKinematicTopologyDirectedStructure tool; + tool.WriteStep(SW, anent); + } + break; + case 795: + { + DeclareAndCast(StepKinematics_KinematicTopologyNetworkStructure, anent, ent); + RWStepKinematics_RWKinematicTopologyNetworkStructure tool; + tool.WriteStep(SW, anent); + } + break; + case 796: + { + DeclareAndCast(StepKinematics_LinearFlexibleAndPinionPair, anent, ent); + RWStepKinematics_RWLinearFlexibleAndPinionPair tool; + tool.WriteStep(SW, anent); + } + break; + case 797: + { + DeclareAndCast(StepKinematics_LinearFlexibleAndPlanarCurvePair, anent, ent); + RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair tool; + tool.WriteStep(SW, anent); + } + break; + case 798: + { + DeclareAndCast(StepKinematics_LinearFlexibleLinkRepresentation, anent, ent); + RWStepKinematics_RWLinearFlexibleLinkRepresentation tool; + tool.WriteStep(SW, anent); + } + break; + case 800: + { + DeclareAndCast(StepKinematics_ActuatedKinPairAndOrderKinPair, anent, ent); + RWStepKinematics_RWActuatedKinPairAndOrderKinPair tool; + tool.WriteStep(SW, anent); + } + break; + case 801: + { + DeclareAndCast(StepKinematics_MechanismStateRepresentation, anent, ent); + RWStepKinematics_RWMechanismStateRepresentation tool; + tool.WriteStep(SW, anent); + } + break; + default: return; } diff --git a/src/RWStepGeom/FILES b/src/RWStepGeom/FILES index 0798a61801..082b068beb 100755 --- a/src/RWStepGeom/FILES +++ b/src/RWStepGeom/FILES @@ -132,6 +132,8 @@ RWStepGeom_RWSeamCurve.cxx RWStepGeom_RWSeamCurve.hxx RWStepGeom_RWSphericalSurface.cxx RWStepGeom_RWSphericalSurface.hxx +RWStepGeom_RWSuParameters.cxx +RWStepGeom_RWSuParameters.hxx RWStepGeom_RWSurface.cxx RWStepGeom_RWSurface.hxx RWStepGeom_RWSurfaceCurve.cxx diff --git a/src/RWStepGeom/RWStepGeom_RWSuParameters.cxx b/src/RWStepGeom/RWStepGeom_RWSuParameters.cxx new file mode 100644 index 0000000000..b299060c49 --- /dev/null +++ b/src/RWStepGeom/RWStepGeom_RWSuParameters.cxx @@ -0,0 +1,122 @@ +// Created on : Sat May 02 12:41:14 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#include +#include +#include +#include +#include +#include + +//======================================================================= +//function : RWStepGeom_RWSuParameters +//purpose : +//======================================================================= + +RWStepGeom_RWSuParameters::RWStepGeom_RWSuParameters() {} + + +//======================================================================= +//function : ReadStep +//purpose : +//======================================================================= + +void RWStepGeom_RWSuParameters::ReadStep (const Handle(StepData_StepReaderData)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theAch, + const Handle(StepGeom_SuParameters)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,7,theAch,"su_parameters") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theAch, aRepresentationItem_Name); + + // Own fields of SuParameters + + Standard_Real aA; + theData->ReadReal (theNum, 2, "a", theAch, aA); + + Standard_Real aAlpha; + theData->ReadReal (theNum, 3, "alpha", theAch, aAlpha); + + Standard_Real aB; + theData->ReadReal (theNum, 4, "b", theAch, aB); + + Standard_Real aBeta; + theData->ReadReal (theNum, 5, "beta", theAch, aBeta); + + Standard_Real aC; + theData->ReadReal (theNum, 6, "c", theAch, aC); + + Standard_Real aGamma; + theData->ReadReal (theNum, 7, "gamma", theAch, aGamma); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aA, + aAlpha, + aB, + aBeta, + aC, + aGamma); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= + +void RWStepGeom_RWSuParameters::WriteStep (StepData_StepWriter& theSW, + const Handle(StepGeom_SuParameters)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Own fields of SuParameters + + theSW.Send (theEnt->A()); + + theSW.Send (theEnt->Alpha()); + + theSW.Send (theEnt->B()); + + theSW.Send (theEnt->Beta()); + + theSW.Send (theEnt->C()); + + theSW.Send (theEnt->Gamma()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= + +void RWStepGeom_RWSuParameters::Share (const Handle(StepGeom_SuParameters)& /*theEnt*/, + Interface_EntityIterator& /*iter*/) const +{ + + // Inherited fields of RepresentationItem + + // Own fields of SuParameters +} diff --git a/src/RWStepGeom/RWStepGeom_RWSuParameters.hxx b/src/RWStepGeom/RWStepGeom_RWSuParameters.hxx new file mode 100644 index 0000000000..0e68ea0c8d --- /dev/null +++ b/src/RWStepGeom/RWStepGeom_RWSuParameters.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:14 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepGeom_RWSuParameters_HeaderFile_ +#define _RWStepGeom_RWSuParameters_HeaderFile_ + +#include +#include +#include + +class StepData_StepReaderData; +class Interface_Check; +class StepData_StepWriter; +class Interface_EntityIterator; +class StepGeom_SuParameters; + +//! Read & Write tool for SuParameters +class RWStepGeom_RWSuParameters +{ +public: + + DEFINE_STANDARD_ALLOC + + Standard_EXPORT RWStepGeom_RWSuParameters(); + + Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theAch, const Handle(StepGeom_SuParameters)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepGeom_SuParameters)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepGeom_SuParameters)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepGeom_RWSuParameters_HeaderFile_ diff --git a/src/RWStepKinematics/FILES b/src/RWStepKinematics/FILES new file mode 100644 index 0000000000..9aa1669306 --- /dev/null +++ b/src/RWStepKinematics/FILES @@ -0,0 +1,148 @@ +RWStepKinematics_RWActuatedKinematicPair.cxx +RWStepKinematics_RWActuatedKinematicPair.hxx +RWStepKinematics_RWContextDependentKinematicLinkRepresentation.cxx +RWStepKinematics_RWContextDependentKinematicLinkRepresentation.hxx +RWStepKinematics_RWCylindricalPair.cxx +RWStepKinematics_RWCylindricalPair.hxx +RWStepKinematics_RWCylindricalPairValue.cxx +RWStepKinematics_RWCylindricalPairValue.hxx +RWStepKinematics_RWCylindricalPairWithRange.cxx +RWStepKinematics_RWCylindricalPairWithRange.hxx +RWStepKinematics_RWFullyConstrainedPair.cxx +RWStepKinematics_RWFullyConstrainedPair.hxx +RWStepKinematics_RWGearPair.cxx +RWStepKinematics_RWGearPair.hxx +RWStepKinematics_RWGearPairValue.cxx +RWStepKinematics_RWGearPairValue.hxx +RWStepKinematics_RWGearPairWithRange.cxx +RWStepKinematics_RWGearPairWithRange.hxx +RWStepKinematics_RWHomokineticPair.cxx +RWStepKinematics_RWHomokineticPair.hxx +RWStepKinematics_RWActuatedKinPairAndOrderKinPair.cxx +RWStepKinematics_RWActuatedKinPairAndOrderKinPair.hxx +RWStepKinematics_RWKinematicJoint.cxx +RWStepKinematics_RWKinematicJoint.hxx +RWStepKinematics_RWKinematicLink.cxx +RWStepKinematics_RWKinematicLink.hxx +RWStepKinematics_RWKinematicLinkRepresentationAssociation.cxx +RWStepKinematics_RWKinematicLinkRepresentationAssociation.hxx +RWStepKinematics_RWKinematicPropertyMechanismRepresentation.cxx +RWStepKinematics_RWKinematicPropertyMechanismRepresentation.hxx +RWStepKinematics_RWKinematicTopologyStructure.cxx +RWStepKinematics_RWKinematicTopologyStructure.hxx +RWStepKinematics_RWLinearFlexibleAndPinionPair.cxx +RWStepKinematics_RWLinearFlexibleAndPinionPair.hxx +RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair.cxx +RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair.hxx +RWStepKinematics_RWLinearFlexibleLinkRepresentation.cxx +RWStepKinematics_RWLinearFlexibleLinkRepresentation.hxx +RWStepKinematics_RWLowOrderKinematicPair.cxx +RWStepKinematics_RWLowOrderKinematicPair.hxx +RWStepKinematics_RWLowOrderKinematicPairValue.cxx +RWStepKinematics_RWLowOrderKinematicPairValue.hxx +RWStepKinematics_RWLowOrderKinematicPairWithRange.cxx +RWStepKinematics_RWLowOrderKinematicPairWithRange.hxx +RWStepKinematics_RWMechanismRepresentation.cxx +RWStepKinematics_RWMechanismRepresentation.hxx +RWStepKinematics_RWMechanismStateRepresentation.cxx +RWStepKinematics_RWMechanismStateRepresentation.hxx +RWStepKinematics_RWOrientedJoint.cxx +RWStepKinematics_RWOrientedJoint.hxx +RWStepKinematics_RWPairRepresentationRelationship.cxx +RWStepKinematics_RWPairRepresentationRelationship.hxx +RWStepKinematics_RWPlanarCurvePair.cxx +RWStepKinematics_RWPlanarCurvePair.hxx +RWStepKinematics_RWPlanarCurvePairRange.cxx +RWStepKinematics_RWPlanarCurvePairRange.hxx +RWStepKinematics_RWPlanarPair.cxx +RWStepKinematics_RWPlanarPair.hxx +RWStepKinematics_RWPlanarPairValue.cxx +RWStepKinematics_RWPlanarPairValue.hxx +RWStepKinematics_RWPlanarPairWithRange.cxx +RWStepKinematics_RWPlanarPairWithRange.hxx +RWStepKinematics_RWPointOnPlanarCurvePair.cxx +RWStepKinematics_RWPointOnPlanarCurvePair.hxx +RWStepKinematics_RWPointOnPlanarCurvePairValue.cxx +RWStepKinematics_RWPointOnPlanarCurvePairValue.hxx +RWStepKinematics_RWPointOnPlanarCurvePairWithRange.cxx +RWStepKinematics_RWPointOnPlanarCurvePairWithRange.hxx +RWStepKinematics_RWPointOnSurfacePair.cxx +RWStepKinematics_RWPointOnSurfacePair.hxx +RWStepKinematics_RWPointOnSurfacePairValue.cxx +RWStepKinematics_RWPointOnSurfacePairValue.hxx +RWStepKinematics_RWPointOnSurfacePairWithRange.cxx +RWStepKinematics_RWPointOnSurfacePairWithRange.hxx +RWStepKinematics_RWPrismaticPair.cxx +RWStepKinematics_RWPrismaticPair.hxx +RWStepKinematics_RWPrismaticPairValue.cxx +RWStepKinematics_RWPrismaticPairValue.hxx +RWStepKinematics_RWPrismaticPairWithRange.cxx +RWStepKinematics_RWPrismaticPairWithRange.hxx +RWStepKinematics_RWProductDefinitionKinematics.cxx +RWStepKinematics_RWProductDefinitionKinematics.hxx +RWStepKinematics_RWProductDefinitionRelationshipKinematics.cxx +RWStepKinematics_RWProductDefinitionRelationshipKinematics.hxx +RWStepKinematics_RWRackAndPinionPair.cxx +RWStepKinematics_RWRackAndPinionPair.hxx +RWStepKinematics_RWRackAndPinionPairValue.cxx +RWStepKinematics_RWRackAndPinionPairValue.hxx +RWStepKinematics_RWRackAndPinionPairWithRange.cxx +RWStepKinematics_RWRackAndPinionPairWithRange.hxx +RWStepKinematics_RWRevolutePair.cxx +RWStepKinematics_RWRevolutePair.hxx +RWStepKinematics_RWRevolutePairValue.cxx +RWStepKinematics_RWRevolutePairValue.hxx +RWStepKinematics_RWRevolutePairWithRange.cxx +RWStepKinematics_RWRevolutePairWithRange.hxx +RWStepKinematics_RWRigidLinkRepresentation.cxx +RWStepKinematics_RWRigidLinkRepresentation.hxx +RWStepKinematics_RWRollingCurvePair.cxx +RWStepKinematics_RWRollingCurvePair.hxx +RWStepKinematics_RWRollingCurvePairValue.cxx +RWStepKinematics_RWRollingCurvePairValue.hxx +RWStepKinematics_RWRollingSurfacePair.cxx +RWStepKinematics_RWRollingSurfacePair.hxx +RWStepKinematics_RWRollingSurfacePairValue.cxx +RWStepKinematics_RWRollingSurfacePairValue.hxx +RWStepKinematics_RWRotationAboutDirection.cxx +RWStepKinematics_RWRotationAboutDirection.hxx +RWStepKinematics_RWScrewPair.cxx +RWStepKinematics_RWScrewPair.hxx +RWStepKinematics_RWScrewPairValue.cxx +RWStepKinematics_RWScrewPairValue.hxx +RWStepKinematics_RWScrewPairWithRange.cxx +RWStepKinematics_RWScrewPairWithRange.hxx +RWStepKinematics_RWSlidingCurvePair.cxx +RWStepKinematics_RWSlidingCurvePair.hxx +RWStepKinematics_RWSlidingCurvePairValue.cxx +RWStepKinematics_RWSlidingCurvePairValue.hxx +RWStepKinematics_RWSlidingSurfacePair.cxx +RWStepKinematics_RWSlidingSurfacePair.hxx +RWStepKinematics_RWSlidingSurfacePairValue.cxx +RWStepKinematics_RWSlidingSurfacePairValue.hxx +RWStepKinematics_RWSphericalPair.cxx +RWStepKinematics_RWSphericalPair.hxx +RWStepKinematics_RWSphericalPairValue.cxx +RWStepKinematics_RWSphericalPairValue.hxx +RWStepKinematics_RWSphericalPairWithPin.cxx +RWStepKinematics_RWSphericalPairWithPin.hxx +RWStepKinematics_RWSphericalPairWithPinAndRange.cxx +RWStepKinematics_RWSphericalPairWithPinAndRange.hxx +RWStepKinematics_RWSphericalPairWithRange.cxx +RWStepKinematics_RWSphericalPairWithRange.hxx +RWStepKinematics_RWSurfacePairWithRange.cxx +RWStepKinematics_RWSurfacePairWithRange.hxx +RWStepKinematics_RWKinematicTopologyDirectedStructure.cxx +RWStepKinematics_RWKinematicTopologyDirectedStructure.hxx +RWStepKinematics_RWKinematicTopologyNetworkStructure.cxx +RWStepKinematics_RWKinematicTopologyNetworkStructure.hxx +RWStepKinematics_RWUnconstrainedPair.cxx +RWStepKinematics_RWUnconstrainedPair.hxx +RWStepKinematics_RWUnconstrainedPairValue.cxx +RWStepKinematics_RWUnconstrainedPairValue.hxx +RWStepKinematics_RWUniversalPair.cxx +RWStepKinematics_RWUniversalPair.hxx +RWStepKinematics_RWUniversalPairValue.cxx +RWStepKinematics_RWUniversalPairValue.hxx +RWStepKinematics_RWUniversalPairWithRange.cxx +RWStepKinematics_RWUniversalPairWithRange.hxx \ No newline at end of file diff --git a/src/RWStepKinematics/RWStepKinematics_RWActuatedKinPairAndOrderKinPair.cxx b/src/RWStepKinematics/RWStepKinematics_RWActuatedKinPairAndOrderKinPair.cxx new file mode 100644 index 0000000000..54cbc333d5 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWActuatedKinPairAndOrderKinPair.cxx @@ -0,0 +1,2309 @@ +// Created on: 2020-05-26 +// Created by: PASUKHIN DMITRY +// Copyright (c) 2020 OPEN CASCADE SAS +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//function : RWStepDimTol_RWGeoTolAndGeoTolWthMod +//purpose : +//======================================================================= +RWStepKinematics_RWActuatedKinPairAndOrderKinPair::RWStepKinematics_RWActuatedKinPairAndOrderKinPair() +{ +} + + +//======================================================================= +//function : ReadStep +//purpose : +//======================================================================= +void RWStepKinematics_RWActuatedKinPairAndOrderKinPair::ReadStep +(const Handle(StepData_StepReaderData)& theData, + const Standard_Integer num0, Handle(Interface_Check)& theArch, + const Handle(StepKinematics_ActuatedKinPairAndOrderKinPair)& theEnt) const +{ + Standard_Integer theNum = 0;//num0; + theData->NamedForComplex("ACTUATED_KINEMATIC_PAIR", "ACKNPR", num0, theNum, theArch); + if (!theData->CheckNbParams(theNum, 6, theArch, "kinematic actuated_kinematic_pair")) return; + // Own fields of ActuatedKinematicPair + Handle(StepKinematics_ActuatedKinematicPair) anActuatedKinematicPair = + new StepKinematics_ActuatedKinematicPair; + StepKinematics_ActuatedDirection aTX = StepKinematics_adNotActuated; + Standard_Boolean hasTX = Standard_True; + if (theData->IsParamDefined(theNum, 1)) + { + if (theData->ParamType(theNum, 1) == Interface_ParamEnum) + { + Standard_CString text = theData->ParamCValue(theNum, 1); + if (strcmp(text, ".BIDIRECTIONAL.")) aTX = StepKinematics_adBidirectional; + else if (strcmp(text, ".POSITIVE_ONLY.")) aTX = StepKinematics_adPositiveOnly; + else if (strcmp(text, ".NEGATIVE_ONLY.")) aTX = StepKinematics_adNegativeOnly; + else if (strcmp(text, ".NOT_ACTUATED.")) aTX = StepKinematics_adNotActuated; + else theArch->AddFail("Parameter #1 (t_x) has not allowed value"); + } + else theArch->AddFail("Parameter #1 (t_x) is not enumeration"); + } + else + { + hasTX = Standard_False; + } + + StepKinematics_ActuatedDirection aTY = StepKinematics_adNotActuated; + Standard_Boolean hasTY = Standard_True; + if (theData->IsParamDefined(theNum, 2)) + { + if (theData->ParamType(theNum, 2) == Interface_ParamEnum) + { + Standard_CString text = theData->ParamCValue(theNum, 8); + if (strcmp(text, ".BIDIRECTIONAL.")) aTY = StepKinematics_adBidirectional; + else if (strcmp(text, ".POSITIVE_ONLY.")) aTY = StepKinematics_adPositiveOnly; + else if (strcmp(text, ".NEGATIVE_ONLY.")) aTY = StepKinematics_adNegativeOnly; + else if (strcmp(text, ".NOT_ACTUATED.")) aTY = StepKinematics_adNotActuated; + else theArch->AddFail("Parameter #2 (t_y) has not allowed value"); + } + else theArch->AddFail("Parameter #2 (t_y) is not enumeration"); + } + else + { + hasTY = Standard_False; + } + + StepKinematics_ActuatedDirection aTZ = StepKinematics_adNotActuated; + Standard_Boolean hasTZ = Standard_True; + if (theData->IsParamDefined(theNum, 3)) + { + if (theData->ParamType(theNum, 3) == Interface_ParamEnum) + { + Standard_CString text = theData->ParamCValue(theNum, 9); + if (strcmp(text, ".BIDIRECTIONAL.")) aTZ = StepKinematics_adBidirectional; + else if (strcmp(text, ".POSITIVE_ONLY.")) aTZ = StepKinematics_adPositiveOnly; + else if (strcmp(text, ".NEGATIVE_ONLY.")) aTZ = StepKinematics_adNegativeOnly; + else if (strcmp(text, ".NOT_ACTUATED.")) aTZ = StepKinematics_adNotActuated; + else theArch->AddFail("Parameter #3 (t_z) has not allowed value"); + } + else theArch->AddFail("Parameter #3 (t_z) is not enumeration"); + } + else + { + hasTZ = Standard_False; + } + + StepKinematics_ActuatedDirection aRX = StepKinematics_adNotActuated; + Standard_Boolean hasRX = Standard_True; + if (theData->IsParamDefined(theNum, 4)) + { + if (theData->ParamType(theNum, 4) == Interface_ParamEnum) + { + Standard_CString text = theData->ParamCValue(theNum, 10); + if (strcmp(text, ".BIDIRECTIONAL.")) aRX = StepKinematics_adBidirectional; + else if (strcmp(text, ".POSITIVE_ONLY.")) aRX = StepKinematics_adPositiveOnly; + else if (strcmp(text, ".NEGATIVE_ONLY.")) aRX = StepKinematics_adNegativeOnly; + else if (strcmp(text, ".NOT_ACTUATED.")) aRX = StepKinematics_adNotActuated; + else theArch->AddFail("Parameter #14 (r_x) has not allowed value"); + } + else theArch->AddFail("Parameter #14 (r_x) is not enumeration"); + } + else + { + hasRX = Standard_False; + } + + StepKinematics_ActuatedDirection aRY = StepKinematics_adNotActuated; + Standard_Boolean hasRY = Standard_True; + if (theData->IsParamDefined(theNum, 5)) + { + if (theData->ParamType(theNum, 5) == Interface_ParamEnum) + { + Standard_CString text = theData->ParamCValue(theNum, 11); + if (strcmp(text, ".BIDIRECTIONAL.")) aRY = StepKinematics_adBidirectional; + else if (strcmp(text, ".POSITIVE_ONLY.")) aRY = StepKinematics_adPositiveOnly; + else if (strcmp(text, ".NEGATIVE_ONLY.")) aRY = StepKinematics_adNegativeOnly; + else if (strcmp(text, ".NOT_ACTUATED.")) aRY = StepKinematics_adNotActuated; + else theArch->AddFail("Parameter #5 (r_y) has not allowed value"); + } + else theArch->AddFail("Parameter #5 (r_y) is not enumeration"); + } + else + { + hasRY = Standard_False; + } + + StepKinematics_ActuatedDirection aRZ = StepKinematics_adNotActuated; + Standard_Boolean hasRZ = Standard_True; + if (theData->IsParamDefined(theNum, 6)) + { + if (theData->ParamType(theNum, 6) == Interface_ParamEnum) + { + Standard_CString text = theData->ParamCValue(theNum, 12); + if (strcmp(text, ".BIDIRECTIONAL.")) aRZ = StepKinematics_adBidirectional; + else if (strcmp(text, ".POSITIVE_ONLY.")) aRZ = StepKinematics_adPositiveOnly; + else if (strcmp(text, ".NEGATIVE_ONLY.")) aRZ = StepKinematics_adNegativeOnly; + else if (strcmp(text, ".NOT_ACTUATED.")) aRZ = StepKinematics_adNotActuated; + else theArch->AddFail("Parameter #6 (r_z) has not allowed value"); + } + else theArch->AddFail("Parameter #6 (r_z) is not enumeration"); + } + else + { + hasRZ = Standard_False; + } + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->NamedForComplex("GEOMETRIC_REPRESENTATION_ITEM", "GMRPIT", num0, theNum, theArch); + //geometricrepresentation_item is non-defined + + theData->NamedForComplex("ITEM_DEFINED_TRANSFORMATION", "ITDFTR", num0, theNum, theArch); + // Own fields of item_defined_transformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + if (strcmp(theData->ParamCValue(theNum, 1), "*")) + theData->ReadString(theNum, 1, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if (theData->IsParamDefined(theNum, 2)) + { + theData->ReadString(theNum, 2, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else + { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity(theNum, 3, "ITEM_DEFINED_TRANSFORMATION", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity(theNum, 4, "ITEM_DEFINED_TRANSFORMATION", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + theData->NamedForComplex("KINEMATIC_PAIR", "KNMPR", num0, theNum, theArch); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity(theNum, 1, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + //Select pair supertype + theNum = theData->NextForComplex(theNum); + Standard_CString aPairSuperType = theData->CType(theNum); + Handle(StepKinematics_KinematicPair) aKinematicPair; + if (!strcmp(aPairSuperType, "LOW_ORDER_KINEMATIC_PAIR")) + { + // Own fields of low_order_kinematic_pair + Standard_Boolean aLowOrderKinematicPair_TX = Standard_True; + Standard_Boolean aLowOrderKinematicPair_TY = Standard_True; + Standard_Boolean aLowOrderKinematicPair_TZ = Standard_True; + Standard_Boolean aLowOrderKinematicPair_RX = Standard_True; + Standard_Boolean aLowOrderKinematicPair_RY = Standard_True; + Standard_Boolean aLowOrderKinematicPair_RZ = Standard_True; + if (theData->CheckNbParams(theNum, 6, theArch, "LOW_ORDER_KINEMATIC_PAIR")) + { + if (strcmp(theData->ParamCValue(theNum, 1), "*")) + theData->ReadBoolean(theNum, 1, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX); + if (strcmp(theData->ParamCValue(theNum, 2), "*")) + theData->ReadBoolean(theNum, 2, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY); + if (strcmp(theData->ParamCValue(theNum, 3), "*")) + theData->ReadBoolean(theNum, 3, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ); + if (strcmp(theData->ParamCValue(theNum, 4), "*")) + theData->ReadBoolean(theNum, 4, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX); + if (strcmp(theData->ParamCValue(theNum, 5), "*")) + theData->ReadBoolean(theNum, 5, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY); + if (strcmp(theData->ParamCValue(theNum, 6), "*")) + theData->ReadBoolean(theNum, 6, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ); + } + else theArch->AddFail("The supertype of kinematic pair is not supported"); + aKinematicPair = new StepKinematics_KinematicPair; + aKinematicPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint); + theNum = theData->NextForComplex(theNum); + Standard_CString aPairtype = theData->CType(theNum); + if (!strcmp(aPairtype, "REVOLUTE_PAIR")) + { + // Own fields of revolute_pair is non-defined + + if (theData->NamedForComplex("REVOLUTE_PAIR_WITH_RANGE", "RPWR", num0, theNum, theArch)) + { + if (theData->CheckNbParams(theNum, 2, theArch, "REVOLUTE_PAIR_WITH_RANGE")) + { + // Own fields of revolute_pair_with_range + aKinematicPair = new StepKinematics_RevolutePairWithRange; + Standard_Real aLowerLimitActualRotation; + Standard_Boolean hasLowerLimitActualRotation = Standard_True; + if (theData->IsParamDefined(theNum, 1)) + { + theData->ReadReal(theNum, 1, "lower_limit_actual_rotation", theArch, aLowerLimitActualRotation); + } + else + { + hasLowerLimitActualRotation = Standard_False; + aLowerLimitActualRotation = 0; + } + + Standard_Real aUpperLimitActualRotation; + Standard_Boolean hasUpperLimitActualRotation = Standard_True; + if (theData->IsParamDefined(theNum, 2)) + { + theData->ReadReal(theNum, 2, "upper_limit_actual_rotation", theArch, aUpperLimitActualRotation); + } + else + { + hasUpperLimitActualRotation = Standard_False; + aUpperLimitActualRotation = 0; + } + Handle(StepKinematics_RevolutePairWithRange) aLocalPair = Handle(StepKinematics_RevolutePairWithRange)::DownCast(aKinematicPair); + // Initialize kinematic_pair + aLocalPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ, + hasLowerLimitActualRotation, + aLowerLimitActualRotation, + hasUpperLimitActualRotation, + aUpperLimitActualRotation); + } + else // revolute_pair_with_range hasn't params + { + aKinematicPair = new StepKinematics_RevolutePair; + Handle(StepKinematics_RevolutePair) aLocalPair = Handle(StepKinematics_RevolutePair)::DownCast(aKinematicPair); + // Initialize kinematic_pair + aLocalPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ); + } + } + } + else if (!strcmp(aPairtype, "CYLINDRICAL_PAIR")) + { + // Own fields of cylindrical_pair is non-defined + + if (theData->NamedForComplex("CYLINDRICAL_PAIR_WITH_RANGE", "CPW0", num0, theNum, theArch)) + { + if (theData->CheckNbParams(theNum, 4, theArch, "CYLINDRICAL_PAIR_WITH_RANGE")) + { + // Own fields of cylindrical_pair_with_range + aKinematicPair = new StepKinematics_CylindricalPairWithRange; + + Standard_Real aLowerLimitActualTranslation; + Standard_Boolean hasLowerLimitActualTranslation = Standard_True; + if (theData->IsParamDefined(theNum, 1)) + { + theData->ReadReal(theNum, 1, "lower_limit_actual_translation", theArch, aLowerLimitActualTranslation); + } + else + { + hasLowerLimitActualTranslation = Standard_False; + aLowerLimitActualTranslation = 0; + } + + Standard_Real aUpperLimitActualTranslation; + Standard_Boolean hasUpperLimitActualTranslation = Standard_True; + if (theData->IsParamDefined(theNum, 2)) + { + theData->ReadReal(theNum, 2, "upper_limit_actual_translation", theArch, aUpperLimitActualTranslation); + } + else + { + hasUpperLimitActualTranslation = Standard_False; + aUpperLimitActualTranslation = 0; + } + + Standard_Real aLowerLimitActualRotation; + Standard_Boolean hasLowerLimitActualRotation = Standard_True; + if (theData->IsParamDefined(theNum, 3)) + { + theData->ReadReal(theNum, 3, "lower_limit_actual_rotation", theArch, aLowerLimitActualRotation); + } + else + { + hasLowerLimitActualRotation = Standard_False; + aLowerLimitActualRotation = 0; + } + + Standard_Real aUpperLimitActualRotation; + Standard_Boolean hasUpperLimitActualRotation = Standard_True; + if (theData->IsParamDefined(theNum, 4)) + { + theData->ReadReal(theNum, 4, "upper_limit_actual_rotation", theArch, aUpperLimitActualRotation); + } + else + { + hasUpperLimitActualRotation = Standard_False; + aUpperLimitActualRotation = 0; + } + Handle(StepKinematics_CylindricalPairWithRange) aLocalPair = Handle(StepKinematics_CylindricalPairWithRange)::DownCast(aKinematicPair); + // Initialize kinematic_pair + aLocalPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ, + hasLowerLimitActualTranslation, + aLowerLimitActualTranslation, + hasUpperLimitActualTranslation, + aUpperLimitActualTranslation, + hasLowerLimitActualRotation, + aLowerLimitActualRotation, + hasUpperLimitActualRotation, + aUpperLimitActualRotation); + } + else // cylindrical_pair_with_range hasn't params + { + aKinematicPair = new StepKinematics_CylindricalPair; + Handle(StepKinematics_CylindricalPair) aLocalPair = Handle(StepKinematics_CylindricalPair)::DownCast(aKinematicPair); + // Initialize kinematic_pair + aLocalPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ); + } + } + } + else if (!strcmp(aPairtype, "SPHERICAL_PAIR")) + { + // Own fields of cylindrical_pair is non-defined + + if (theData->NamedForComplex("SPHERICAL_PAIR_WITH_RANGE", "SPW0", num0, theNum, theArch)) + { + if (theData->CheckNbParams(theNum, 6, theArch, "SPHERICAL_PAIR_WITH_RANGE")) + { + // Own fields of spherical_pair_with_range + aKinematicPair = new StepKinematics_SphericalPairWithRange; + + Standard_Real aLowerLimitYaw; + Standard_Boolean hasLowerLimitYaw = Standard_True; + if (theData->IsParamDefined(theNum, 1)) + { + theData->ReadReal(theNum, 1, "lower_limit_yaw", theArch, aLowerLimitYaw); + } + else + { + hasLowerLimitYaw = Standard_False; + aLowerLimitYaw = 0; + } + + Standard_Real aUpperLimitYaw; + Standard_Boolean hasUpperLimitYaw = Standard_True; + if (theData->IsParamDefined(theNum, 2)) + { + theData->ReadReal(theNum, 2, "upper_limit_yaw", theArch, aUpperLimitYaw); + } + else + { + hasUpperLimitYaw = Standard_False; + aUpperLimitYaw = 0; + } + + Standard_Real aLowerLimitPitch; + Standard_Boolean hasLowerLimitPitch = Standard_True; + if (theData->IsParamDefined(theNum, 3)) + { + theData->ReadReal(theNum, 3, "lower_limit_pitch", theArch, aLowerLimitPitch); + } + else + { + hasLowerLimitPitch = Standard_False; + aLowerLimitPitch = 0; + } + + Standard_Real aUpperLimitPitch; + Standard_Boolean hasUpperLimitPitch = Standard_True; + if (theData->IsParamDefined(theNum, 4)) + { + theData->ReadReal(theNum, 4, "upper_limit_pitch", theArch, aUpperLimitPitch); + } + else + { + hasUpperLimitPitch = Standard_False; + aUpperLimitPitch = 0; + } + + Standard_Real aLowerLimitRoll; + Standard_Boolean hasLowerLimitRoll = Standard_True; + if (theData->IsParamDefined(theNum, 5)) + { + theData->ReadReal(theNum, 5, "lower_limit_roll", theArch, aLowerLimitRoll); + } + else + { + hasLowerLimitRoll = Standard_False; + aLowerLimitRoll = 0; + } + + Standard_Real aUpperLimitRoll; + Standard_Boolean hasUpperLimitRoll = Standard_True; + if (theData->IsParamDefined(theNum, 6)) + { + theData->ReadReal(theNum, 6, "upper_limit_roll", theArch, aUpperLimitRoll); + } + else + { + hasUpperLimitRoll = Standard_False; + aUpperLimitRoll = 0; + } + Handle(StepKinematics_SphericalPairWithRange) aLocalPair = Handle(StepKinematics_SphericalPairWithRange)::DownCast(aKinematicPair); + // Initialize kinematic_pair + aLocalPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ, + hasLowerLimitYaw, + aLowerLimitYaw, + hasUpperLimitYaw, + aUpperLimitYaw, + hasLowerLimitPitch, + aLowerLimitPitch, + hasUpperLimitPitch, + aUpperLimitPitch, + hasLowerLimitRoll, + aLowerLimitRoll, + hasUpperLimitRoll, + aUpperLimitRoll); + } + else // spherical_pair_with_range hasn't params + { + aKinematicPair = new StepKinematics_SphericalPair; + Handle(StepKinematics_SphericalPair) aLocalPair = Handle(StepKinematics_SphericalPair)::DownCast(aKinematicPair); + // Initialize kinematic_pair + aLocalPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ); + } + } + } + else if (!strcmp(aPairtype, "SPHERICAL_PAIR_WITH_PIN")) + { + // Own fields of spherical_pair_with_pin is non-defined + + if (theData->NamedForComplex("SPHERICAL_PAIR_WITH_PIN_AND_RANGE", "SPWPAR", num0, theNum, theArch)) + { + if (theData->CheckNbParams(theNum, 4, theArch, "SPHERICAL_PAIR_WITH_PIN_AND_RANGE")) + { + // Own fields of spherical_pair_with_pin_and_range + aKinematicPair = new StepKinematics_SphericalPairWithPinAndRange; + + + Standard_Real aLowerLimitYaw; + Standard_Boolean hasLowerLimitYaw = Standard_True; + if (theData->IsParamDefined(theNum, 1)) + { + theData->ReadReal(theNum, 1, "lower_limit_yaw", theArch, aLowerLimitYaw); + } + else + { + hasLowerLimitYaw = Standard_False; + aLowerLimitYaw = 0; + } + + Standard_Real aUpperLimitYaw; + Standard_Boolean hasUpperLimitYaw = Standard_True; + if (theData->IsParamDefined(theNum, 2)) + { + theData->ReadReal(theNum, 2, "upper_limit_yaw", theArch, aUpperLimitYaw); + } + else + { + hasUpperLimitYaw = Standard_False; + aUpperLimitYaw = 0; + } + + Standard_Real aLowerLimitRoll; + Standard_Boolean hasLowerLimitRoll = Standard_True; + if (theData->IsParamDefined(theNum, 3)) + { + theData->ReadReal(theNum, 3, "lower_limit_roll", theArch, aLowerLimitRoll); + } + else + { + hasLowerLimitRoll = Standard_False; + aLowerLimitRoll = 0; + } + + Standard_Real aUpperLimitRoll; + Standard_Boolean hasUpperLimitRoll = Standard_True; + if (theData->IsParamDefined(theNum, 4)) + { + theData->ReadReal(theNum, 4, "upper_limit_roll", theArch, aUpperLimitRoll); + } + else + { + hasUpperLimitRoll = Standard_False; + aUpperLimitRoll = 0; + } + Handle(StepKinematics_SphericalPairWithPinAndRange) aLocalPair = Handle(StepKinematics_SphericalPairWithPinAndRange)::DownCast(aKinematicPair); + // Initialize kinematic_pair + aLocalPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ, + hasLowerLimitYaw, + aLowerLimitYaw, + hasUpperLimitYaw, + aUpperLimitYaw, + hasLowerLimitRoll, + aLowerLimitRoll, + hasUpperLimitRoll, + aUpperLimitRoll); + } + else // spherical_pair_with_pin_and_range hasn't params + { + aKinematicPair = new StepKinematics_SphericalPairWithPin; + Handle(StepKinematics_SphericalPairWithPin) aLocalPair = Handle(StepKinematics_SphericalPairWithPin)::DownCast(aKinematicPair); + // Initialize kinematic_pair + aLocalPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ); + } + } + else theArch->AddFail("The type of kinematic pair with range is not supported"); + } + else if (!strcmp(aPairtype, "PRISMATIC_PAIR")) + { + // Own fields of prismatic_pair is non-defined + + if (theData->NamedForComplex("PRISMATIC_PAIR_WITH_RANGE", "PPW0", num0, theNum, theArch)) + { + if (theData->CheckNbParams(theNum, 2, theArch, "PRISMATIC_PAIR_WITH_RANGE")) + { + aKinematicPair = new StepKinematics_PrismaticPairWithRange; + // Own fields of prismatic_pair_with_range + + Standard_Real aLowerLimitActualTranslation; + Standard_Boolean hasLowerLimitActualTranslation = Standard_True; + if (theData->IsParamDefined(theNum, 1)) + { + theData->ReadReal(theNum, 1, "lower_limit_actual_translation", theArch, aLowerLimitActualTranslation); + } + else + { + hasLowerLimitActualTranslation = Standard_False; + aLowerLimitActualTranslation = 0; + } + + Standard_Real aUpperLimitActualTranslation; + Standard_Boolean hasUpperLimitActualTranslation = Standard_True; + if (theData->IsParamDefined(theNum, 2)) + { + theData->ReadReal(theNum, 2, "upper_limit_actual_translation", theArch, aUpperLimitActualTranslation); + } + else + { + hasUpperLimitActualTranslation = Standard_False; + aUpperLimitActualTranslation = 0; + } + Handle(StepKinematics_PrismaticPairWithRange) aLocalPair = Handle(StepKinematics_PrismaticPairWithRange)::DownCast(aKinematicPair); + // Initialize kinematic_pair + aLocalPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ, + hasLowerLimitActualTranslation, + aLowerLimitActualTranslation, + hasUpperLimitActualTranslation, + aUpperLimitActualTranslation); + } + else // prismatic_pair_with_range hasn't params + { + aKinematicPair = new StepKinematics_PrismaticPair; + Handle(StepKinematics_PrismaticPair) aLocalPair = Handle(StepKinematics_PrismaticPair)::DownCast(aKinematicPair); + // Initialize kinematic_pair + aLocalPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ); + } + } + } + else if (!strcmp(aPairtype, "UNIVERSAL_PAIR")) + { + // Own fields of universal_pair + + aKinematicPair = new StepKinematics_UniversalPair; + Standard_Real aInputSkewAngle; + Standard_Boolean hasInputSkewAngle = Standard_True; + if (theData->IsParamDefined(theNum, 1)) + { + theData->ReadReal(theNum, 1, "input_skew_angle", theArch, aInputSkewAngle); + } + else + { + hasInputSkewAngle = Standard_False; + aInputSkewAngle = 0; + } + + if (theData->NamedForComplex("UNIVERSAL_PAIR_WITH_RANGE", "UPWR", num0, theNum, theArch)) + { + if (theData->CheckNbParams(theNum, 4, theArch, "UNIVERSAL_PAIR_WITH_RANGE")) + { + // Own fields of universal_pair_with_range + + Standard_Real aLowerLimitFirstRotation; + Standard_Boolean hasLowerLimitFirstRotation = Standard_True; + if (theData->IsParamDefined(theNum, 1)) + { + theData->ReadReal(theNum, 1, "lower_limit_first_rotation", theArch, aLowerLimitFirstRotation); + } + else + { + hasLowerLimitFirstRotation = Standard_False; + aLowerLimitFirstRotation = 0; + } + + Standard_Real aUpperLimitFirstRotation; + Standard_Boolean hasUpperLimitFirstRotation = Standard_True; + if (theData->IsParamDefined(theNum, 2)) + { + theData->ReadReal(theNum, 2, "upper_limit_first_rotation", theArch, aUpperLimitFirstRotation); + } + else + { + hasUpperLimitFirstRotation = Standard_False; + aUpperLimitFirstRotation = 0; + } + + Standard_Real aLowerLimitSecondRotation; + Standard_Boolean hasLowerLimitSecondRotation = Standard_True; + if (theData->IsParamDefined(theNum, 3)) + { + theData->ReadReal(theNum, 3, "lower_limit_second_rotation", theArch, aLowerLimitSecondRotation); + } + else + { + hasLowerLimitSecondRotation = Standard_False; + aLowerLimitSecondRotation = 0; + } + + Standard_Real aUpperLimitSecondRotation; + Standard_Boolean hasUpperLimitSecondRotation = Standard_True; + if (theData->IsParamDefined(theNum, 4)) + { + theData->ReadReal(theNum, 4, "upper_limit_second_rotation", theArch, aUpperLimitSecondRotation); + } + else + { + hasUpperLimitSecondRotation = Standard_False; + aUpperLimitSecondRotation = 0; + } + aKinematicPair = new StepKinematics_UniversalPairWithRange; + Handle(StepKinematics_UniversalPairWithRange) aLocalPair = Handle(StepKinematics_UniversalPairWithRange)::DownCast(aKinematicPair); + // Initialize kinematic_pair + aLocalPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ, + hasInputSkewAngle, + aInputSkewAngle, + hasLowerLimitFirstRotation, + aLowerLimitFirstRotation, + hasUpperLimitFirstRotation, + aUpperLimitFirstRotation, + hasLowerLimitSecondRotation, + aLowerLimitSecondRotation, + hasUpperLimitSecondRotation, + aUpperLimitSecondRotation); + } + else // universal_pair_with_range hasn't params + { + aKinematicPair = new StepKinematics_UniversalPair; + Handle(StepKinematics_UniversalPair) aLocalPair = Handle(StepKinematics_UniversalPair)::DownCast(aKinematicPair); + // Initialize kinematic_pair + aLocalPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ, + hasInputSkewAngle, + aInputSkewAngle); + } + } + } + else if (!strcmp(aPairtype, "PLANAR_PAIR")) + { + // Own fields of planar_pair is non-defined + + if (theData->NamedForComplex("PLANAR_PAIR_WITH_RANGE", "PPWR", num0, theNum, theArch)) + { + if (theData->CheckNbParams(theNum, 6, theArch, "UNIVERSAL_PAIR_WITH_RANGE")) + { + // Own fields of universal_pair_with_range + + aKinematicPair = new StepKinematics_PlanarPairWithRange; + Standard_Real aLowerLimitActualRotation; + Standard_Boolean hasLowerLimitActualRotation = Standard_True; + if (theData->IsParamDefined(theNum, 1)) + { + theData->ReadReal(theNum, 1, "lower_limit_actual_rotation", theArch, aLowerLimitActualRotation); + } + else + { + hasLowerLimitActualRotation = Standard_False; + aLowerLimitActualRotation = 0; + } + + Standard_Real aUpperLimitActualRotation; + Standard_Boolean hasUpperLimitActualRotation = Standard_True; + if (theData->IsParamDefined(theNum, 2)) + { + theData->ReadReal(theNum, 2, "upper_limit_actual_rotation", theArch, aUpperLimitActualRotation); + } + else + { + hasUpperLimitActualRotation = Standard_False; + aUpperLimitActualRotation = 0; + } + + Standard_Real aLowerLimitActualTranslationX; + Standard_Boolean hasLowerLimitActualTranslationX = Standard_True; + if (theData->IsParamDefined(theNum, 3)) + { + theData->ReadReal(theNum, 3, "lower_limit_actual_translation_x", theArch, aLowerLimitActualTranslationX); + } + else + { + hasLowerLimitActualTranslationX = Standard_False; + aLowerLimitActualTranslationX = 0; + } + + Standard_Real aUpperLimitActualTranslationX; + Standard_Boolean hasUpperLimitActualTranslationX = Standard_True; + if (theData->IsParamDefined(theNum, 4)) + { + theData->ReadReal(theNum, 4, "upper_limit_actual_translation_x", theArch, aUpperLimitActualTranslationX); + } + else + { + hasUpperLimitActualTranslationX = Standard_False; + aUpperLimitActualTranslationX = 0; + } + + Standard_Real aLowerLimitActualTranslationY; + Standard_Boolean hasLowerLimitActualTranslationY = Standard_True; + if (theData->IsParamDefined(theNum, 5)) + { + theData->ReadReal(theNum, 5, "lower_limit_actual_translation_y", theArch, aLowerLimitActualTranslationY); + } + else + { + hasLowerLimitActualTranslationY = Standard_False; + aLowerLimitActualTranslationY = 0; + } + + Standard_Real aUpperLimitActualTranslationY; + Standard_Boolean hasUpperLimitActualTranslationY = Standard_True; + if (theData->IsParamDefined(theNum, 6)) + { + theData->ReadReal(theNum, 6, "upper_limit_actual_translation_y", theArch, aUpperLimitActualTranslationY); + } + else + { + hasUpperLimitActualTranslationY = Standard_False; + aUpperLimitActualTranslationY = 0; + } + Handle(StepKinematics_PlanarPairWithRange) aLocalPair = Handle(StepKinematics_PlanarPairWithRange)::DownCast(aKinematicPair); + // Initialize kinematic_pair + aLocalPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ, + hasLowerLimitActualRotation, + aLowerLimitActualRotation, + hasUpperLimitActualRotation, + aUpperLimitActualRotation, + hasLowerLimitActualTranslationX, + aLowerLimitActualTranslationX, + hasUpperLimitActualTranslationX, + aUpperLimitActualTranslationX, + hasLowerLimitActualTranslationY, + aLowerLimitActualTranslationY, + hasUpperLimitActualTranslationY, + aUpperLimitActualTranslationY); + } + else // universal_pair_with_range hasn't params + { + aKinematicPair = new StepKinematics_PlanarPair; + Handle(StepKinematics_PlanarPair) aLocalPair = Handle(StepKinematics_PlanarPair)::DownCast(aKinematicPair); + // Initialize kinematic_pair + aLocalPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ); + } + } + } + } + else if (!strcmp(aPairSuperType, "LOW_ORDER_KINEMATIC_PAIR_WITH_MOTION_COUPLING")) + { + theNum = theData->NextForComplex(theNum); + Standard_CString aPairtype = theData->CType(theNum); + if (!strcmp(aPairtype, "GEAR_PAIR")) + { + + // Inherited fields of GearPair + + Standard_Real aGearPair_RadiusFirstLink; + theData->ReadReal(theNum, 1, "gear_pair.radius_first_link", theArch, aGearPair_RadiusFirstLink); + + Standard_Real aGearPair_RadiusSecondLink; + theData->ReadReal(theNum, 2, "gear_pair.radius_second_link", theArch, aGearPair_RadiusSecondLink); + + Standard_Real aGearPair_Bevel; + theData->ReadReal(theNum, 3, "gear_pair.bevel", theArch, aGearPair_Bevel); + + Standard_Real aGearPair_HelicalAngle; + theData->ReadReal(theNum, 4, "gear_pair.helical_angle", theArch, aGearPair_HelicalAngle); + + Standard_Real aGearPair_GearRatio; + theData->ReadReal(theNum, 5, "gear_pair.gear_ratio", theArch, aGearPair_GearRatio); + + if (theData->NamedForComplex("GEAR_PAIR_WITH_RANGE", "GPWR", num0, theNum, theArch)) + { + if (theData->CheckNbParams(theNum, 2, theArch, "GEAR_PAIR_WITH_RANGE")) + { + // Own fields of GearPairWithRange + + aKinematicPair = new StepKinematics_GearPairWithRange; + + Standard_Real aLowerLimitActualRotation1; + Standard_Boolean hasLowerLimitActualRotation1 = Standard_True; + if (theData->IsParamDefined(theNum, 1)) + { + theData->ReadReal(theNum, 1, "lower_limit_actual_rotation1", theArch, aLowerLimitActualRotation1); + } + else + { + hasLowerLimitActualRotation1 = Standard_False; + aLowerLimitActualRotation1 = 0; + } + + Standard_Real aUpperLimitActualRotation1; + Standard_Boolean hasUpperLimitActualRotation1 = Standard_True; + if (theData->IsParamDefined(theNum, 2)) + { + theData->ReadReal(theNum, 2, "upper_limit_actual_rotation1", theArch, aUpperLimitActualRotation1); + } + else + { + hasUpperLimitActualRotation1 = Standard_False; + aUpperLimitActualRotation1 = 0; + } + Handle(StepKinematics_GearPairWithRange) aLocalPair = Handle(StepKinematics_GearPairWithRange)::DownCast(aKinematicPair); + // Initialize kinematic_pair + aLocalPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aGearPair_RadiusFirstLink, + aGearPair_RadiusSecondLink, + aGearPair_Bevel, + aGearPair_HelicalAngle, + aGearPair_GearRatio, + hasLowerLimitActualRotation1, + aLowerLimitActualRotation1, + hasUpperLimitActualRotation1, + aUpperLimitActualRotation1); + + } + else // StepKinematics_GearPairWithRange hasn't params + { + aKinematicPair = new StepKinematics_GearPair; + Handle(StepKinematics_GearPair) aLocalPair = Handle(StepKinematics_GearPair)::DownCast(aKinematicPair); + // Initialize kinematic_pair + aLocalPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aGearPair_RadiusFirstLink, + aGearPair_RadiusSecondLink, + aGearPair_Bevel, + aGearPair_HelicalAngle, + aGearPair_GearRatio); + } + } + } + else if (!strcmp(aPairtype, "RACK_AND_PINION_PAIR")) + { + + // Inherited fields of RackAndPinionPair + Standard_Real aRackAndPinionPair_PinionRadius; + theData->ReadReal(theNum, 1, "rack_and_pinion_pair.pinion_radius", theArch, aRackAndPinionPair_PinionRadius); + + if (theData->NamedForComplex("RACK_AND_PINION_PAIR_WITH_RANGE", "RAPPWR", num0, theNum, theArch)) + { + if (theData->CheckNbParams(theNum, 2, theArch, "RACK_AND_PINION_PAIR_WITH_RANGE")) + { + // Own fields of GearPairWithRange + + aKinematicPair = new StepKinematics_RackAndPinionPairWithRange; + + + Standard_Real aLowerLimitRackDisplacement; + Standard_Boolean hasLowerLimitRackDisplacement = Standard_True; + if (theData->IsParamDefined(theNum, 1)) + { + theData->ReadReal(theNum, 1, "lower_limit_rack_displacement", theArch, aLowerLimitRackDisplacement); + } + else + { + hasLowerLimitRackDisplacement = Standard_False; + aLowerLimitRackDisplacement = 0; + } + + Standard_Real aUpperLimitRackDisplacement; + Standard_Boolean hasUpperLimitRackDisplacement = Standard_True; + if (theData->IsParamDefined(theNum, 2)) + { + theData->ReadReal(theNum, 2, "upper_limit_rack_displacement", theArch, aUpperLimitRackDisplacement); + } + else + { + hasUpperLimitRackDisplacement = Standard_False; + aUpperLimitRackDisplacement = 0; + } + + Handle(StepKinematics_RackAndPinionPairWithRange) aLocalPair = Handle(StepKinematics_RackAndPinionPairWithRange)::DownCast(aKinematicPair); + // Initialize kinematic_pair + aLocalPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aRackAndPinionPair_PinionRadius, + hasLowerLimitRackDisplacement, + aLowerLimitRackDisplacement, + hasUpperLimitRackDisplacement, + aUpperLimitRackDisplacement); + } + else // StepKinematics_RackAndPinionPairWithRange hasn't params + { + aKinematicPair = new StepKinematics_RackAndPinionPair; + Handle(StepKinematics_RackAndPinionPair) aLocalPair = Handle(StepKinematics_RackAndPinionPair)::DownCast(aKinematicPair); + // Initialize kinematic_pair + aLocalPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aRackAndPinionPair_PinionRadius); + } + } + } + else if (!strcmp(aPairtype, "SCREW_PAIR")) + { + // Inherited fields of ScrewPair + + Standard_Real aScrewPair_Pitch; + theData->ReadReal(theNum, 1, "screw_pair.pitch", theArch, aScrewPair_Pitch); + + if (theData->NamedForComplex("SCREW_PAIR_WITH_RANGE", "SPWR", num0, theNum, theArch)) + { + if (theData->CheckNbParams(theNum, 2, theArch, "SCREW_PAIR_WITH_RANGE")) + { + // Own fields of ScrewPairWithRange + + aKinematicPair = new StepKinematics_ScrewPairWithRange; + Standard_Real aLowerLimitActualRotation; + Standard_Boolean hasLowerLimitActualRotation = Standard_True; + if (theData->IsParamDefined(theNum, 1)) + { + theData->ReadReal(theNum, 1, "lower_limit_actual_rotation", theArch, aLowerLimitActualRotation); + } + else + { + hasLowerLimitActualRotation = Standard_False; + aLowerLimitActualRotation = 0; + } + + Standard_Real aUpperLimitActualRotation; + Standard_Boolean hasUpperLimitActualRotation = Standard_True; + if (theData->IsParamDefined(theNum, 2)) + { + theData->ReadReal(theNum, 2, "upper_limit_actual_rotation", theArch, aUpperLimitActualRotation); + } + else + { + hasUpperLimitActualRotation = Standard_False; + aUpperLimitActualRotation = 0; + } + + Handle(StepKinematics_ScrewPairWithRange) aLocalPair = Handle(StepKinematics_ScrewPairWithRange)::DownCast(aKinematicPair); + // Initialize kinematic_pair + aLocalPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aScrewPair_Pitch, + hasLowerLimitActualRotation, + aLowerLimitActualRotation, + hasUpperLimitActualRotation, + aUpperLimitActualRotation); + } + else // StepKinematics_ScrewPairWithRange hasn't params + { + aKinematicPair = new StepKinematics_ScrewPair; + Handle(StepKinematics_ScrewPair) aLocalPair = Handle(StepKinematics_ScrewPair)::DownCast(aKinematicPair); + // Initialize kinematic_pair + aLocalPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aScrewPair_Pitch); + } + } + } + } + else // "HIGH_ORDER_KINEMATIC_PAIR" + { + theNum = theData->NextForComplex(theNum); + Standard_CString aPairtype = theData->CType(theNum); + if (!strcmp(aPairtype, "POINT_ON_PLANAR_CURVE_PAIR")) + { + + // Inherited fields of PointOnPlanarCurvePair + + Handle(StepGeom_Curve) aPointOnPlanarCurvePair_PairCurve; + theData->ReadEntity(theNum, 1, "point_on_planar_curve_pair.pair_curve", theArch, STANDARD_TYPE(StepGeom_Curve), aPointOnPlanarCurvePair_PairCurve); + + Standard_Boolean aPointOnPlanarCurvePair_Orientation; + theData->ReadBoolean(theNum, 2, "point_on_planar_curve_pair.orientation", theArch, aPointOnPlanarCurvePair_Orientation); + + + if (theData->NamedForComplex("POINT_ON_PLANAR_CURVE_PAIR_WITH_RANGE", "POPCPW", num0, theNum, theArch)) + { + if (theData->CheckNbParams(theNum, 7, theArch, "POINT_ON_PLANAR_CURVE_PAIR_WITH_RANGE")) + { + // Own fields of PointOnPlanarCurvePairWithRange + + aKinematicPair = new StepKinematics_PointOnPlanarCurvePairWithRange; + + Handle(StepGeom_TrimmedCurve) aRangeOnPairCurve; + theData->ReadEntity(theNum, 1, "range_on_pair_curve", theArch, STANDARD_TYPE(StepGeom_TrimmedCurve), aRangeOnPairCurve); + + Standard_Real aLowerLimitYaw; + Standard_Boolean hasLowerLimitYaw = Standard_True; + if (theData->IsParamDefined(theNum, 2)) + { + theData->ReadReal(theNum, 2, "lower_limit_yaw", theArch, aLowerLimitYaw); + } + else + { + hasLowerLimitYaw = Standard_False; + aLowerLimitYaw = 0; + } + + Standard_Real aUpperLimitYaw; + Standard_Boolean hasUpperLimitYaw = Standard_True; + if (theData->IsParamDefined(theNum, 3)) + { + theData->ReadReal(theNum, 3, "upper_limit_yaw", theArch, aUpperLimitYaw); + } + else + { + hasUpperLimitYaw = Standard_False; + aUpperLimitYaw = 0; + } + + Standard_Real aLowerLimitPitch; + Standard_Boolean hasLowerLimitPitch = Standard_True; + if (theData->IsParamDefined(theNum, 4)) + { + theData->ReadReal(theNum, 4, "lower_limit_pitch", theArch, aLowerLimitPitch); + } + else + { + hasLowerLimitPitch = Standard_False; + aLowerLimitPitch = 0; + } + + Standard_Real aUpperLimitPitch; + Standard_Boolean hasUpperLimitPitch = Standard_True; + if (theData->IsParamDefined(theNum, 5)) + { + theData->ReadReal(theNum, 5, "upper_limit_pitch", theArch, aUpperLimitPitch); + } + else + { + hasUpperLimitPitch = Standard_False; + aUpperLimitPitch = 0; + } + + Standard_Real aLowerLimitRoll; + Standard_Boolean hasLowerLimitRoll = Standard_True; + if (theData->IsParamDefined(theNum, 6)) + { + theData->ReadReal(theNum, 6, "lower_limit_roll", theArch, aLowerLimitRoll); + } + else + { + hasLowerLimitRoll = Standard_False; + aLowerLimitRoll = 0; + } + + Standard_Real aUpperLimitRoll; + Standard_Boolean hasUpperLimitRoll = Standard_True; + if (theData->IsParamDefined(theNum, 7)) + { + theData->ReadReal(theNum, 7, "upper_limit_roll", theArch, aUpperLimitRoll); + } + else + { + hasUpperLimitRoll = Standard_False; + aUpperLimitRoll = 0; + } + Handle(StepKinematics_PointOnPlanarCurvePairWithRange) aLocalPair = Handle(StepKinematics_PointOnPlanarCurvePairWithRange)::DownCast(aKinematicPair); + // Initialize kinematic_pair + aLocalPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aPointOnPlanarCurvePair_PairCurve, + aPointOnPlanarCurvePair_Orientation, + aRangeOnPairCurve, + hasLowerLimitYaw, + aLowerLimitYaw, + hasUpperLimitYaw, + aUpperLimitYaw, + hasLowerLimitPitch, + aLowerLimitPitch, + hasUpperLimitPitch, + aUpperLimitPitch, + hasLowerLimitRoll, + aLowerLimitRoll, + hasUpperLimitRoll, + aUpperLimitRoll); + + } + else // point_on_planar_curve_pair_with_range hasn't params + { + aKinematicPair = new StepKinematics_PointOnPlanarCurvePair; + Handle(StepKinematics_PointOnPlanarCurvePair) aLocalPair = Handle(StepKinematics_PointOnPlanarCurvePair)::DownCast(aKinematicPair); + // Initialize kinematic_pair + aLocalPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aPointOnPlanarCurvePair_PairCurve, + aPointOnPlanarCurvePair_Orientation); + } + } + } + else if (!strcmp(aPairtype, "POINT_ON_SURFACE_PAIR")) + { + // Inherited fields of PointOnSurfacePair + + Handle(StepGeom_Surface) aPointOnSurfacePair_PairSurface; + theData->ReadEntity(theNum, 1, "point_on_surface_pair.pair_surface", theArch, STANDARD_TYPE(StepGeom_Surface), aPointOnSurfacePair_PairSurface); + + if (theData->NamedForComplex("POINT_ON_SURFACE_PAIR_WITH_RANGE ", "RAPPWR", num0, theNum, theArch)) + { + if (theData->CheckNbParams(theNum, 2, theArch, "POINT_ON_SURFACE_PAIR_WITH_RANGE ")) + { + // Own fields of PointOnSurfacePairWithRange + + aKinematicPair = new StepKinematics_PointOnSurfacePairWithRange; + + + Handle(StepGeom_RectangularTrimmedSurface) aRangeOnPairSurface; + theData->ReadEntity(theNum, 1, "range_on_pair_surface", theArch, STANDARD_TYPE(StepGeom_RectangularTrimmedSurface), aRangeOnPairSurface); + + Standard_Real aLowerLimitYaw; + Standard_Boolean hasLowerLimitYaw = Standard_True; + if (theData->IsParamDefined(theNum, 2)) + { + theData->ReadReal(theNum, 2, "lower_limit_yaw", theArch, aLowerLimitYaw); + } + else + { + hasLowerLimitYaw = Standard_False; + aLowerLimitYaw = 0; + } + + Standard_Real aUpperLimitYaw; + Standard_Boolean hasUpperLimitYaw = Standard_True; + if (theData->IsParamDefined(theNum, 3)) + { + theData->ReadReal(theNum, 3, "upper_limit_yaw", theArch, aUpperLimitYaw); + } + else + { + hasUpperLimitYaw = Standard_False; + aUpperLimitYaw = 0; + } + + Standard_Real aLowerLimitPitch; + Standard_Boolean hasLowerLimitPitch = Standard_True; + if (theData->IsParamDefined(theNum, 4)) + { + theData->ReadReal(theNum, 4, "lower_limit_pitch", theArch, aLowerLimitPitch); + } + else + { + hasLowerLimitPitch = Standard_False; + aLowerLimitPitch = 0; + } + + Standard_Real aUpperLimitPitch; + Standard_Boolean hasUpperLimitPitch = Standard_True; + if (theData->IsParamDefined(theNum, 5)) + { + theData->ReadReal(theNum, 5, "upper_limit_pitch", theArch, aUpperLimitPitch); + } + else + { + hasUpperLimitPitch = Standard_False; + aUpperLimitPitch = 0; + } + + Standard_Real aLowerLimitRoll; + Standard_Boolean hasLowerLimitRoll = Standard_True; + if (theData->IsParamDefined(theNum, 6)) + { + theData->ReadReal(theNum, 6, "lower_limit_roll", theArch, aLowerLimitRoll); + } + else + { + hasLowerLimitRoll = Standard_False; + aLowerLimitRoll = 0; + } + + Standard_Real aUpperLimitRoll; + Standard_Boolean hasUpperLimitRoll = Standard_True; + if (theData->IsParamDefined(theNum, 7)) + { + theData->ReadReal(theNum, 7, "upper_limit_roll", theArch, aUpperLimitRoll); + } + else + { + hasUpperLimitRoll = Standard_False; + aUpperLimitRoll = 0; + } + Handle(StepKinematics_PointOnSurfacePairWithRange) aLocalPair = Handle(StepKinematics_PointOnSurfacePairWithRange)::DownCast(aKinematicPair); + // Initialize kinematic_pair + aLocalPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aPointOnSurfacePair_PairSurface, + aRangeOnPairSurface, + hasLowerLimitYaw, + aLowerLimitYaw, + hasUpperLimitYaw, + aUpperLimitYaw, + hasLowerLimitPitch, + aLowerLimitPitch, + hasUpperLimitPitch, + aUpperLimitPitch, + hasLowerLimitRoll, + aLowerLimitRoll, + hasUpperLimitRoll, + aUpperLimitRoll); + } + else // StepKinematics_PointOnSurfacePairWithRange hasn't params + { + aKinematicPair = new StepKinematics_PointOnSurfacePair; + Handle(StepKinematics_PointOnSurfacePair) aLocalPair = Handle(StepKinematics_PointOnSurfacePair)::DownCast(aKinematicPair); + // Initialize kinematic_pair + aLocalPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aPointOnSurfacePair_PairSurface); + } + } + } + else if (!strcmp(aPairtype, "PLANAR_CURVE_PAIR")) + { + // Inherited fields of PlanarCurvePair + + Handle(StepGeom_Curve) aPlanarCurvePair_Curve1; + theData->ReadEntity(theNum, 1, "planar_curve_pair.curve1", theArch, STANDARD_TYPE(StepGeom_Curve), aPlanarCurvePair_Curve1); + + Handle(StepGeom_Curve) aPlanarCurvePair_Curve2; + theData->ReadEntity(theNum, 2, "planar_curve_pair.curve2", theArch, STANDARD_TYPE(StepGeom_Curve), aPlanarCurvePair_Curve2); + + Standard_Boolean aPlanarCurvePair_Orientation; + theData->ReadBoolean(theNum, 3, "planar_curve_pair.orientation", theArch, aPlanarCurvePair_Orientation); + + if (theData->NamedForComplex("PLANAR_CURVE_PAIR_RANGE", "PCPR", num0, theNum, theArch)) + { + if (theData->CheckNbParams(theNum, 2, theArch, "PLANAR_CURVE_PAIR_RANGE")) + { + // Own fields of PlanarCurvePairRange + aKinematicPair = new StepKinematics_PlanarCurvePairRange; + + Handle(StepGeom_TrimmedCurve) aRangeOnCurve1; + theData->ReadEntity(theNum, 1, "range_on_curve1", theArch, STANDARD_TYPE(StepGeom_TrimmedCurve), aRangeOnCurve1); + + Handle(StepGeom_TrimmedCurve) aRangeOnCurve2; + theData->ReadEntity(theNum, 2, "range_on_curve2", theArch, STANDARD_TYPE(StepGeom_TrimmedCurve), aRangeOnCurve2); + + + Handle(StepKinematics_PlanarCurvePairRange) aLocalPair = Handle(StepKinematics_PlanarCurvePairRange)::DownCast(aKinematicPair); + // Initialize kinematic_pair + aLocalPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aPlanarCurvePair_Curve1, + aPlanarCurvePair_Curve2, + aPlanarCurvePair_Orientation, + aRangeOnCurve1, + aRangeOnCurve2); + } + else // StepKinematics_ScrewPairWithRange hasn't params + { + aKinematicPair = new StepKinematics_PlanarCurvePair; + Handle(StepKinematics_PlanarCurvePair) aLocalPair = Handle(StepKinematics_PlanarCurvePair)::DownCast(aKinematicPair); + // Initialize kinematic_pair + aLocalPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aPlanarCurvePair_Curve1, + aPlanarCurvePair_Curve2, + aPlanarCurvePair_Orientation); + } + } + } + else if (!strcmp(aPairtype, "SURFACE_PAIR")) + { + // Inherited fields of SurfacePair + + Handle(StepGeom_Surface) aSurfacePair_Surface1; + theData->ReadEntity(theNum, 1, "surface_pair.surface1", theArch, STANDARD_TYPE(StepGeom_Surface), aSurfacePair_Surface1); + + Handle(StepGeom_Surface) aSurfacePair_Surface2; + theData->ReadEntity(theNum, 2, "surface_pair.surface2", theArch, STANDARD_TYPE(StepGeom_Surface), aSurfacePair_Surface2); + + Standard_Boolean aSurfacePair_Orientation; + theData->ReadBoolean(theNum, 3, "surface_pair.orientation", theArch, aSurfacePair_Orientation); + + if (theData->NamedForComplex("SURFACE_PAIR_WITH_RANGE", "SPW1", num0, theNum, theArch)) + { + if (theData->CheckNbParams(theNum, 4, theArch, "SURFACE_PAIR_WITH_RANGE")) + { + aKinematicPair = new StepKinematics_SurfacePairWithRange; + // Own fields of SurfacePairWithRange + + Handle(StepGeom_RectangularTrimmedSurface) aRangeOnSurface1; + theData->ReadEntity(theNum, 1, "range_on_surface1", theArch, STANDARD_TYPE(StepGeom_RectangularTrimmedSurface), aRangeOnSurface1); + + Handle(StepGeom_RectangularTrimmedSurface) aRangeOnSurface2; + theData->ReadEntity(theNum, 2, "range_on_surface2", theArch, STANDARD_TYPE(StepGeom_RectangularTrimmedSurface), aRangeOnSurface2); + + Standard_Real aLowerLimitActualRotation; + Standard_Boolean hasLowerLimitActualRotation = Standard_True; + if (theData->IsParamDefined(theNum, 3)) + { + theData->ReadReal(theNum, 3, "lower_limit_actual_rotation", theArch, aLowerLimitActualRotation); + } + else + { + hasLowerLimitActualRotation = Standard_False; + aLowerLimitActualRotation = 0; + } + + Standard_Real aUpperLimitActualRotation; + Standard_Boolean hasUpperLimitActualRotation = Standard_True; + if (theData->IsParamDefined(theNum, 4)) + { + theData->ReadReal(theNum, 4, "upper_limit_actual_rotation", theArch, aUpperLimitActualRotation); + } + else + { + hasUpperLimitActualRotation = Standard_False; + aUpperLimitActualRotation = 0; + } + + Handle(StepKinematics_SurfacePairWithRange) aLocalPair = Handle(StepKinematics_SurfacePairWithRange)::DownCast(aKinematicPair); + // Initialize kinematic_pair + aLocalPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aSurfacePair_Surface1, + aSurfacePair_Surface2, + aSurfacePair_Orientation, + aRangeOnSurface1, + aRangeOnSurface2, + hasLowerLimitActualRotation, + aLowerLimitActualRotation, + hasUpperLimitActualRotation, + aUpperLimitActualRotation); + } + else // StepKinematics_SurfacePairWithRange hasn't params + { + aKinematicPair = new StepKinematics_SurfacePair; + Handle(StepKinematics_SurfacePair) aLocalPair = Handle(StepKinematics_SurfacePair)::DownCast(aKinematicPair); + // Initialize kinematic_pair + aLocalPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aSurfacePair_Surface1, + aSurfacePair_Surface2, + aSurfacePair_Orientation); + } + } + } + } + theData->NamedForComplex("REPRESENTATION_ITEM", "RPRITM", num0, theNum, theArch); + + // Own fields of representation_item + theData->ReadString(theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + anActuatedKinematicPair->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, hasTX, aTX, hasTY, aTY, hasTZ, + aTZ, hasRX, aRX, hasRY, aRY, hasRZ, aRZ); + + // Initialize kinematic_pair + aKinematicPair->SetName(aRepresentationItem_Name); + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + anActuatedKinematicPair, aKinematicPair); +} + + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWActuatedKinPairAndOrderKinPair::WriteStep +(StepData_StepWriter& theSW, + const Handle(StepKinematics_ActuatedKinPairAndOrderKinPair)& theEnt) const +{ + // --- Instance of plex componant BoundedCurve --- + + theSW.StartEntity("(ACTUATED_KINEMATIC_PAIR"); + + if (theEnt->GetActuatedKinematicPair()->HasTX()) + { + switch (theEnt->GetActuatedKinematicPair()->TX()) + { + case StepKinematics_adBidirectional: theSW.SendEnum(".BIDIRECTIONAL."); break; + case StepKinematics_adPositiveOnly: theSW.SendEnum(".POSITIVE_ONLY."); break; + case StepKinematics_adNegativeOnly: theSW.SendEnum(".NEGATIVE_ONLY."); break; + case StepKinematics_adNotActuated: theSW.SendEnum(".NOT_ACTUATED."); break; + } + } + else theSW.SendUndef(); + + if (theEnt->GetActuatedKinematicPair()->HasTY()) + { + switch (theEnt->GetActuatedKinematicPair()->TY()) + { + case StepKinematics_adBidirectional: theSW.SendEnum(".BIDIRECTIONAL."); break; + case StepKinematics_adPositiveOnly: theSW.SendEnum(".POSITIVE_ONLY."); break; + case StepKinematics_adNegativeOnly: theSW.SendEnum(".NEGATIVE_ONLY."); break; + case StepKinematics_adNotActuated: theSW.SendEnum(".NOT_ACTUATED."); break; + } + } + else theSW.SendUndef(); + + if (theEnt->GetActuatedKinematicPair()->HasTZ()) + { + switch (theEnt->GetActuatedKinematicPair()->TZ()) + { + case StepKinematics_adBidirectional: theSW.SendEnum(".BIDIRECTIONAL."); break; + case StepKinematics_adPositiveOnly: theSW.SendEnum(".POSITIVE_ONLY."); break; + case StepKinematics_adNegativeOnly: theSW.SendEnum(".NEGATIVE_ONLY."); break; + case StepKinematics_adNotActuated: theSW.SendEnum(".NOT_ACTUATED."); break; + } + } + else theSW.SendUndef(); + + if (theEnt->GetActuatedKinematicPair()->HasRX()) + { + switch (theEnt->GetActuatedKinematicPair()->RX()) + { + case StepKinematics_adBidirectional: theSW.SendEnum(".BIDIRECTIONAL."); break; + case StepKinematics_adPositiveOnly: theSW.SendEnum(".POSITIVE_ONLY."); break; + case StepKinematics_adNegativeOnly: theSW.SendEnum(".NEGATIVE_ONLY."); break; + case StepKinematics_adNotActuated: theSW.SendEnum(".NOT_ACTUATED."); break; + } + } + else theSW.SendUndef(); + + if (theEnt->GetActuatedKinematicPair()->HasRY()) + { + switch (theEnt->GetActuatedKinematicPair()->RY()) + { + case StepKinematics_adBidirectional: theSW.SendEnum(".BIDIRECTIONAL."); break; + case StepKinematics_adPositiveOnly: theSW.SendEnum(".POSITIVE_ONLY."); break; + case StepKinematics_adNegativeOnly: theSW.SendEnum(".NEGATIVE_ONLY."); break; + case StepKinematics_adNotActuated: theSW.SendEnum(".NOT_ACTUATED."); break; + } + } + else theSW.SendUndef(); + + if (theEnt->GetActuatedKinematicPair()->HasRZ()) + { + switch (theEnt->GetActuatedKinematicPair()->RZ()) + { + case StepKinematics_adBidirectional: theSW.SendEnum(".BIDIRECTIONAL."); break; + case StepKinematics_adPositiveOnly: theSW.SendEnum(".POSITIVE_ONLY."); break; + case StepKinematics_adNegativeOnly: theSW.SendEnum(".NEGATIVE_ONLY."); break; + case StepKinematics_adNotActuated: theSW.SendEnum(".NOT_ACTUATED."); break; + } + } + else theSW.SendUndef(); + theSW.StartEntity("(GEOMETRIC_REPRESENTATION_ITEM"); + + theSW.StartEntity("(ITEM_DEFINED_TRANSFORMATION"); + // Inherited fields of ItemDefinedTransformation + + theSW.Send(theEnt->ItemDefinedTransformation()->Name()); + + if (theEnt->ItemDefinedTransformation()->HasDescription()) + { + theSW.Send(theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send(theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send(theEnt->ItemDefinedTransformation()->TransformItem2()); + + theSW.StartEntity("(KINEMATIC_PAIR"); + + // Own fields of KinematicPair + + theSW.Send(theEnt->Joint()); + if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_LowOrderKinematicPair))) + { + Handle(StepKinematics_LowOrderKinematicPair) aLowOrderKinematicPair = Handle(StepKinematics_LowOrderKinematicPair)::DownCast(theEnt->GetOrderKinematicPair()); + theSW.StartEntity("(LOW_ORDER_KINEMATIC_PAIR"); + + theSW.SendBoolean(aLowOrderKinematicPair->TX()); + + theSW.SendBoolean(aLowOrderKinematicPair->TY()); + + theSW.SendBoolean(aLowOrderKinematicPair->TZ()); + + theSW.SendBoolean(aLowOrderKinematicPair->RX()); + + theSW.SendBoolean(aLowOrderKinematicPair->RY()); + + theSW.SendBoolean(aLowOrderKinematicPair->RZ()); + + if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_RevolutePair))) + { + theSW.StartEntity("(REVOLUTE_PAIR"); + theSW.StartEntity("(REVOLUTE_PAIR_WITH_RANGE"); + if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_RevolutePairWithRange))) + { + Handle(StepKinematics_RevolutePairWithRange) aRevolutePairWithRange = Handle(StepKinematics_RevolutePairWithRange)::DownCast(theEnt->GetOrderKinematicPair()); + // Own fields of RevolutePairWithRange + + if (aRevolutePairWithRange->HasLowerLimitActualRotation()) + { + theSW.Send(aRevolutePairWithRange->LowerLimitActualRotation()); + } + else theSW.SendUndef(); + + if (aRevolutePairWithRange->HasUpperLimitActualRotation()) + { + theSW.Send(aRevolutePairWithRange->UpperLimitActualRotation()); + } + else theSW.SendUndef(); + } + } + else if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_CylindricalPair))) + { + theSW.StartEntity("(CYLINDRICAL_PAIR"); + theSW.StartEntity("(CYLINDRICAL_PAIR_WITH_RANGE"); + if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_CylindricalPairWithRange))) + { + Handle(StepKinematics_CylindricalPairWithRange) aCylindricalPairWithRange = Handle(StepKinematics_CylindricalPairWithRange)::DownCast(theEnt->GetOrderKinematicPair()); + // Own fields of CylindricalPairWithRange + + if (aCylindricalPairWithRange->HasLowerLimitActualTranslation()) + { + theSW.Send(aCylindricalPairWithRange->LowerLimitActualTranslation()); + } + else theSW.SendUndef(); + + if (aCylindricalPairWithRange->HasUpperLimitActualTranslation()) + { + theSW.Send(aCylindricalPairWithRange->UpperLimitActualTranslation()); + } + else theSW.SendUndef(); + + if (aCylindricalPairWithRange->HasLowerLimitActualRotation()) + { + theSW.Send(aCylindricalPairWithRange->LowerLimitActualRotation()); + } + else theSW.SendUndef(); + + if (aCylindricalPairWithRange->HasUpperLimitActualRotation()) + { + theSW.Send(aCylindricalPairWithRange->UpperLimitActualRotation()); + } + else theSW.SendUndef(); + } + } + else if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_SphericalPair))) + { + theSW.StartEntity("(SPHERICAL_PAIR"); + theSW.StartEntity("(SPHERICAL_PAIR_WITH_RANGE"); + if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_SphericalPairWithRange))) + { + Handle(StepKinematics_SphericalPairWithRange) aSphericalPairWithRange = Handle(StepKinematics_SphericalPairWithRange)::DownCast(theEnt->GetOrderKinematicPair()); + // Own fields of SphericalPairWithRange + + if (aSphericalPairWithRange->HasLowerLimitYaw()) + { + theSW.Send(aSphericalPairWithRange->LowerLimitYaw()); + } + else theSW.SendUndef(); + + if (aSphericalPairWithRange->HasUpperLimitYaw()) + { + theSW.Send(aSphericalPairWithRange->UpperLimitYaw()); + } + else theSW.SendUndef(); + + if (aSphericalPairWithRange->HasLowerLimitPitch()) + { + theSW.Send(aSphericalPairWithRange->LowerLimitPitch()); + } + else theSW.SendUndef(); + + if (aSphericalPairWithRange->HasUpperLimitPitch()) + { + theSW.Send(aSphericalPairWithRange->UpperLimitPitch()); + } + else theSW.SendUndef(); + + if (aSphericalPairWithRange->HasLowerLimitRoll()) + { + theSW.Send(aSphericalPairWithRange->LowerLimitRoll()); + } + else theSW.SendUndef(); + + if (aSphericalPairWithRange->HasUpperLimitRoll()) + { + theSW.Send(aSphericalPairWithRange->UpperLimitRoll()); + } + else theSW.SendUndef(); + } + } + else if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_SphericalPairWithPin))) + { + theSW.StartEntity("(SPHERICAL_PAIR_WITH_PIN"); + theSW.StartEntity("(SPHERICAL_PAIR_WITH_PIN_AND_RANGE"); + if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_SphericalPairWithPinAndRange))) + { + Handle(StepKinematics_SphericalPairWithPinAndRange) aSphericalPairWithPinAndRange = Handle(StepKinematics_SphericalPairWithPinAndRange)::DownCast(theEnt->GetOrderKinematicPair()); + // Own fields of SphericalPairWithPinAndRange + + if (aSphericalPairWithPinAndRange->HasLowerLimitYaw()) + { + theSW.Send(aSphericalPairWithPinAndRange->LowerLimitYaw()); + } + else theSW.SendUndef(); + + if (aSphericalPairWithPinAndRange->HasUpperLimitYaw()) + { + theSW.Send(aSphericalPairWithPinAndRange->UpperLimitYaw()); + } + else theSW.SendUndef(); + + if (aSphericalPairWithPinAndRange->HasLowerLimitRoll()) + { + theSW.Send(aSphericalPairWithPinAndRange->LowerLimitRoll()); + } + else theSW.SendUndef(); + + if (aSphericalPairWithPinAndRange->HasUpperLimitRoll()) + { + theSW.Send(aSphericalPairWithPinAndRange->UpperLimitRoll()); + } + else theSW.SendUndef(); + } + } + else if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_PrismaticPair))) + { + theSW.StartEntity("(PRISMATIC_PAIR"); + theSW.StartEntity("(PRISMATIC_PAIR_WITH_RANGE"); + if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_PrismaticPairWithRange))) + { + Handle(StepKinematics_PrismaticPairWithRange) aPrismaticPairWithRange = Handle(StepKinematics_PrismaticPairWithRange)::DownCast(theEnt->GetOrderKinematicPair()); + // Own fields of PrismaticPairWithRange + + if (aPrismaticPairWithRange->HasLowerLimitActualTranslation()) + { + theSW.Send(aPrismaticPairWithRange->LowerLimitActualTranslation()); + } + else theSW.SendUndef(); + + if (aPrismaticPairWithRange->HasUpperLimitActualTranslation()) + { + theSW.Send(aPrismaticPairWithRange->UpperLimitActualTranslation()); + } + else theSW.SendUndef(); + } + } + else if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_UniversalPair))) + { + theSW.StartEntity("(UNIVERSAL_PAIR"); + Handle(StepKinematics_UniversalPair) anUniversalPair = Handle(StepKinematics_UniversalPair)::DownCast(theEnt->GetOrderKinematicPair()); + // Own fields of UniversalPair + + if (anUniversalPair->HasInputSkewAngle()) + { + theSW.Send(anUniversalPair->InputSkewAngle()); + } + else theSW.SendUndef(); + + theSW.StartEntity("(PRISMATIC_PAIR_WITH_RANGE"); + if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_PrismaticPairWithRange))) + { + Handle(StepKinematics_UniversalPairWithRange) anUniversalPairWithRange = Handle(StepKinematics_UniversalPairWithRange)::DownCast(theEnt->GetOrderKinematicPair()); + // Own fields of UniversalPairWithRange + + if (anUniversalPairWithRange->HasLowerLimitFirstRotation()) + { + theSW.Send(anUniversalPairWithRange->LowerLimitFirstRotation()); + } + else theSW.SendUndef(); + + if (anUniversalPairWithRange->HasUpperLimitFirstRotation()) + { + theSW.Send(anUniversalPairWithRange->UpperLimitFirstRotation()); + } + else theSW.SendUndef(); + + if (anUniversalPairWithRange->HasLowerLimitSecondRotation()) + { + theSW.Send(anUniversalPairWithRange->LowerLimitSecondRotation()); + } + else theSW.SendUndef(); + + if (anUniversalPairWithRange->HasUpperLimitSecondRotation()) + { + theSW.Send(anUniversalPairWithRange->UpperLimitSecondRotation()); + } + else theSW.SendUndef(); + } + } + } + else if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_LowOrderKinematicPairWithMotionCoupling))) + { + if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_GearPair))) + { + theSW.StartEntity("(GEAR_PAIR"); + Handle(StepKinematics_GearPair) aGearPair = Handle(StepKinematics_GearPair)::DownCast(theEnt->GetOrderKinematicPair()); + // Own fields of GearPair + + theSW.Send(aGearPair->RadiusFirstLink()); + + theSW.Send(aGearPair->RadiusSecondLink()); + + theSW.Send(aGearPair->Bevel()); + + theSW.Send(aGearPair->HelicalAngle()); + + theSW.Send(aGearPair->GearRatio()); + + theSW.StartEntity("(PRISMATIC_PAIR_WITH_RANGE"); + if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_GearPairWithRange))) + { + Handle(StepKinematics_GearPairWithRange) aGearPairWithRange = Handle(StepKinematics_GearPairWithRange)::DownCast(theEnt->GetOrderKinematicPair()); + // Own fields of GearPairWithRange + + if (aGearPairWithRange->HasLowerLimitActualRotation1()) + { + theSW.Send(aGearPairWithRange->LowerLimitActualRotation1()); + } + else theSW.SendUndef(); + + if (aGearPairWithRange->HasUpperLimitActualRotation1()) + { + theSW.Send(aGearPairWithRange->UpperLimitActualRotation1()); + } + else theSW.SendUndef(); + } + } + else if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_RackAndPinionPair))) + { + theSW.StartEntity("RACK_AND_PINION_PAIR"); + Handle(StepKinematics_RackAndPinionPair) aRackAndPinionPair = Handle(StepKinematics_RackAndPinionPair)::DownCast(theEnt->GetOrderKinematicPair()); + // Own fields of RackAndPinionPair + + theSW.Send(aRackAndPinionPair->PinionRadius()); + + theSW.StartEntity("(RACK_AND_PINION_PAIR_WITH_RANGE"); + if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_RackAndPinionPairWithRange))) + { + Handle(StepKinematics_RackAndPinionPairWithRange) aRackAndPinionPairWithRange = Handle(StepKinematics_RackAndPinionPairWithRange)::DownCast(theEnt->GetOrderKinematicPair()); + // Own fields of aRackAndPinionPairWithRange + + if (aRackAndPinionPairWithRange->HasLowerLimitRackDisplacement()) + { + theSW.Send(aRackAndPinionPairWithRange->LowerLimitRackDisplacement()); + } + else theSW.SendUndef(); + + if (aRackAndPinionPairWithRange->HasUpperLimitRackDisplacement()) + { + theSW.Send(aRackAndPinionPairWithRange->UpperLimitRackDisplacement()); + } + else theSW.SendUndef(); + } + } + else if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_ScrewPair))) + { + theSW.StartEntity("SCREW_PAIR"); + Handle(StepKinematics_ScrewPair) aScrewPair = Handle(StepKinematics_ScrewPair)::DownCast(theEnt->GetOrderKinematicPair()); + // Own fields of ScrewPair + + theSW.Send(aScrewPair->Pitch()); + + theSW.StartEntity("(SCREW_PAIR_WITH_RANGE"); + if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_ScrewPairWithRange))) + { + Handle(StepKinematics_ScrewPairWithRange) aScrewPairWithRange = Handle(StepKinematics_ScrewPairWithRange)::DownCast(theEnt->GetOrderKinematicPair()); + // Own fields of aRackAndPinionPairWithRange + + if (aScrewPairWithRange->HasLowerLimitActualRotation()) + { + theSW.Send(aScrewPairWithRange->LowerLimitActualRotation()); + } + else theSW.SendUndef(); + + if (aScrewPairWithRange->HasUpperLimitActualRotation()) + { + theSW.Send(aScrewPairWithRange->UpperLimitActualRotation()); + } + else theSW.SendUndef(); + } + } + } + else if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_HighOrderKinematicPair))) + { + if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_ScrewPair))) + { + theSW.StartEntity("POINT_ON_PLANAR_CURVE_PAIR"); + Handle(StepKinematics_PointOnPlanarCurvePair) aPointOnPlanarCurvePair = Handle(StepKinematics_PointOnPlanarCurvePair)::DownCast(theEnt->GetOrderKinematicPair()); + // Own fields of PointOnPlanarCurvePair + + theSW.Send(aPointOnPlanarCurvePair->PairCurve()); + + theSW.SendBoolean(aPointOnPlanarCurvePair->Orientation()); + + theSW.StartEntity("(POINT_ON_PLANAR_CURVE_PAIR_WITH_RANGE"); + if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_PointOnPlanarCurvePairWithRange))) + { + Handle(StepKinematics_PointOnPlanarCurvePairWithRange) aPointOnPlanarCurvePairWithRange = Handle(StepKinematics_PointOnPlanarCurvePairWithRange)::DownCast(theEnt->GetOrderKinematicPair()); + // Own fields of PointOnPlanarCurvePairWithRange + + theSW.Send(aPointOnPlanarCurvePairWithRange->RangeOnPairCurve()); + + if (aPointOnPlanarCurvePairWithRange->HasLowerLimitYaw()) + { + theSW.Send(aPointOnPlanarCurvePairWithRange->LowerLimitYaw()); + } + else theSW.SendUndef(); + + if (aPointOnPlanarCurvePairWithRange->HasUpperLimitYaw()) + { + theSW.Send(aPointOnPlanarCurvePairWithRange->UpperLimitYaw()); + } + else theSW.SendUndef(); + + if (aPointOnPlanarCurvePairWithRange->HasLowerLimitPitch()) + { + theSW.Send(aPointOnPlanarCurvePairWithRange->LowerLimitPitch()); + } + else theSW.SendUndef(); + + if (aPointOnPlanarCurvePairWithRange->HasUpperLimitPitch()) + { + theSW.Send(aPointOnPlanarCurvePairWithRange->UpperLimitPitch()); + } + else theSW.SendUndef(); + + if (aPointOnPlanarCurvePairWithRange->HasLowerLimitRoll()) + { + theSW.Send(aPointOnPlanarCurvePairWithRange->LowerLimitRoll()); + } + else theSW.SendUndef(); + + if (aPointOnPlanarCurvePairWithRange->HasUpperLimitRoll()) + { + theSW.Send(aPointOnPlanarCurvePairWithRange->UpperLimitRoll()); + } + else theSW.SendUndef(); + } + } + else if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_PointOnSurfacePair))) + { + theSW.StartEntity("POINT_ON_SURFACE_PAIR"); + Handle(StepKinematics_PointOnSurfacePair) aPointOnSurfacePair = Handle(StepKinematics_PointOnSurfacePair)::DownCast(theEnt->GetOrderKinematicPair()); + // Own fields of PointOnSurfacePair + + theSW.Send(aPointOnSurfacePair->PairSurface()); + + theSW.StartEntity("(SCREW_PAIR_WITH_RANGE"); + if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_PointOnSurfacePairWithRange))) + { + Handle(StepKinematics_PointOnSurfacePairWithRange) aPointOnSurfacePairWithRange = Handle(StepKinematics_PointOnSurfacePairWithRange)::DownCast(theEnt->GetOrderKinematicPair()); + // Own fields of PointOnSurfacePairWithRange + + theSW.Send(aPointOnSurfacePairWithRange->RangeOnPairSurface()); + + if (aPointOnSurfacePairWithRange->HasLowerLimitYaw()) + { + theSW.Send(aPointOnSurfacePairWithRange->LowerLimitYaw()); + } + else theSW.SendUndef(); + + if (aPointOnSurfacePairWithRange->HasUpperLimitYaw()) + { + theSW.Send(aPointOnSurfacePairWithRange->UpperLimitYaw()); + } + else theSW.SendUndef(); + + if (aPointOnSurfacePairWithRange->HasLowerLimitPitch()) + { + theSW.Send(aPointOnSurfacePairWithRange->LowerLimitPitch()); + } + else theSW.SendUndef(); + + if (aPointOnSurfacePairWithRange->HasUpperLimitPitch()) + { + theSW.Send(aPointOnSurfacePairWithRange->UpperLimitPitch()); + } + else theSW.SendUndef(); + + if (aPointOnSurfacePairWithRange->HasLowerLimitRoll()) + { + theSW.Send(aPointOnSurfacePairWithRange->LowerLimitRoll()); + } + else theSW.SendUndef(); + + if (aPointOnSurfacePairWithRange->HasUpperLimitRoll()) + { + theSW.Send(aPointOnSurfacePairWithRange->UpperLimitRoll()); + } + else theSW.SendUndef(); + } + } + else if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_PlanarCurvePair))) + { + theSW.StartEntity("PLANAR_CURVE_PAIR"); + Handle(StepKinematics_PlanarCurvePair) aPlanarCurvePair = Handle(StepKinematics_PlanarCurvePair)::DownCast(theEnt->GetOrderKinematicPair()); + // Own fields of PlanarCurvePair + + theSW.Send(aPlanarCurvePair->Curve1()); + + theSW.Send(aPlanarCurvePair->Curve2()); + + theSW.StartEntity("(PLANAR_CURVE_PAIR_RANGE"); + if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_PlanarCurvePairRange))) + { + Handle(StepKinematics_PlanarCurvePairRange) aPlanarCurvePairRange = Handle(StepKinematics_PlanarCurvePairRange)::DownCast(theEnt->GetOrderKinematicPair()); + // Own fields of PlanarCurvePairRange + + theSW.Send(aPlanarCurvePairRange->RangeOnCurve1()); + + theSW.Send(aPlanarCurvePairRange->RangeOnCurve2()); + } + } + else if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_SurfacePair))) + { + theSW.StartEntity("SURFACE_PAIR"); + Handle(StepKinematics_SurfacePair) aSurfacePair = Handle(StepKinematics_SurfacePair)::DownCast(theEnt->GetOrderKinematicPair()); + // Own fields of SurfacePair + + theSW.Send(aSurfacePair->Surface1()); + + theSW.Send(aSurfacePair->Surface2()); + + theSW.SendBoolean(aSurfacePair->Orientation()); + + theSW.StartEntity("(SURFACE_PAIR_WITH_RANGE"); + if (theEnt->GetOrderKinematicPair()->IsKind(STANDARD_TYPE(StepKinematics_SurfacePairWithRange))) + { + Handle(StepKinematics_SurfacePairWithRange) aSurfacePairWithRange = Handle(StepKinematics_SurfacePairWithRange)::DownCast(theEnt->GetOrderKinematicPair()); + // Own fields of SurfacePairWithRange + + theSW.Send(aSurfacePairWithRange->RangeOnSurface1()); + + theSW.Send(aSurfacePairWithRange->RangeOnSurface2()); + + if (aSurfacePairWithRange->HasLowerLimitActualRotation()) + { + theSW.Send(aSurfacePairWithRange->LowerLimitActualRotation()); + } + else theSW.SendUndef(); + + if (aSurfacePairWithRange->HasUpperLimitActualRotation()) + { + theSW.Send(aSurfacePairWithRange->UpperLimitActualRotation()); + } + else theSW.SendUndef(); + } + } + } + + // Own fields of RepresentationItem + theSW.StartEntity("REPRESENTATION_ITEM"); + theSW.Send(theEnt->Name()); +} + + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWActuatedKinPairAndOrderKinPair::Share +(const Handle(StepKinematics_ActuatedKinPairAndOrderKinPair)& theEnt, + Interface_EntityIterator& iter) const +{ + iter.AddItem(theEnt->GetOrderKinematicPair()); + iter.AddItem(theEnt->GetOrderKinematicPair()->Joint()); + iter.AddItem(theEnt->GetActuatedKinematicPair()); + iter.AddItem(theEnt->GetOrderKinematicPair()->ItemDefinedTransformation()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWActuatedKinPairAndOrderKinPair.hxx b/src/RWStepKinematics/RWStepKinematics_RWActuatedKinPairAndOrderKinPair.hxx new file mode 100644 index 0000000000..07a60a2119 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWActuatedKinPairAndOrderKinPair.hxx @@ -0,0 +1,47 @@ +// Created on: 2020-05-26 +// Created by: PASUKHIN DMITRY +// Copyright (c) 2015 OPEN CASCADE SAS +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWActuatedKinPairAndOrderKinPair_HeaderFile +#define _RWStepKinematics_RWActuatedKinPairAndOrderKinPair_HeaderFile + +#include +#include +#include + +#include +class StepData_StepReaderData; +class Interface_Check; +class StepData_StepWriter; +class Interface_EntityIterator; +class StepKinematics_ActuatedKinPairAndOrderKinPair; + + +//! Read & Write Module for GeoTolAndGeoTolWthMod +class RWStepKinematics_RWActuatedKinPairAndOrderKinPair +{ +public: + + DEFINE_STANDARD_ALLOC + + + Standard_EXPORT RWStepKinematics_RWActuatedKinPairAndOrderKinPair(); + + Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_ActuatedKinPairAndOrderKinPair)& theEnt) const; + + Standard_EXPORT void WriteStep (StepData_StepWriter& theSW, const Handle(StepKinematics_ActuatedKinPairAndOrderKinPair)& theEnt) const; + + Standard_EXPORT void Share (const Handle(StepKinematics_ActuatedKinPairAndOrderKinPair)& theEnt, Interface_EntityIterator& iter) const; +}; +#endif // _RWStepDimTol_RWGeoTolAndGeoTolWthMod_HeaderFile diff --git a/src/RWStepKinematics/RWStepKinematics_RWActuatedKinematicPair.cxx b/src/RWStepKinematics/RWStepKinematics_RWActuatedKinematicPair.cxx new file mode 100644 index 0000000000..81c6f23897 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWActuatedKinematicPair.cxx @@ -0,0 +1,318 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_ActuatedKinematicPair)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,12,theArch,"actuated_kinematic_pair") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Own fields of ActuatedKinematicPair + + StepKinematics_ActuatedDirection aTX = StepKinematics_adNotActuated; + Standard_Boolean hasTX = Standard_True; + if ( theData->IsParamDefined (theNum,7) ) { + if (theData->ParamType (theNum, 7) == Interface_ParamEnum) { + Standard_CString text = theData->ParamCValue(theNum, 7); + if (strcmp(text, ".BIDIRECTIONAL.")) aTX = StepKinematics_adBidirectional; + else if (strcmp(text, ".POSITIVE_ONLY.")) aTX = StepKinematics_adPositiveOnly; + else if (strcmp(text, ".NEGATIVE_ONLY.")) aTX = StepKinematics_adNegativeOnly; + else if (strcmp(text, ".NOT_ACTUATED.")) aTX = StepKinematics_adNotActuated; + else theArch->AddFail("Parameter #7 (t_x) has not allowed value"); + } + else theArch->AddFail("Parameter #7 (t_x) is not enumeration"); + } + else { + hasTX = Standard_False; + } + + StepKinematics_ActuatedDirection aTY = StepKinematics_adNotActuated; + Standard_Boolean hasTY = Standard_True; + if ( theData->IsParamDefined (theNum,8) ) { + if (theData->ParamType (theNum, 8) == Interface_ParamEnum) { + Standard_CString text = theData->ParamCValue(theNum, 8); + if (strcmp(text, ".BIDIRECTIONAL.")) aTY = StepKinematics_adBidirectional; + else if (strcmp(text, ".POSITIVE_ONLY.")) aTY = StepKinematics_adPositiveOnly; + else if (strcmp(text, ".NEGATIVE_ONLY.")) aTY = StepKinematics_adNegativeOnly; + else if (strcmp(text, ".NOT_ACTUATED.")) aTY = StepKinematics_adNotActuated; + else theArch->AddFail("Parameter #8 (t_y) has not allowed value"); + } + else theArch->AddFail("Parameter #8 (t_y) is not enumeration"); + } + else { + hasTY = Standard_False; + } + + StepKinematics_ActuatedDirection aTZ = StepKinematics_adNotActuated; + Standard_Boolean hasTZ = Standard_True; + if ( theData->IsParamDefined (theNum,9) ) { + if (theData->ParamType (theNum, 9) == Interface_ParamEnum) { + Standard_CString text = theData->ParamCValue(theNum, 9); + if (strcmp(text, ".BIDIRECTIONAL.")) aTZ = StepKinematics_adBidirectional; + else if (strcmp(text, ".POSITIVE_ONLY.")) aTZ = StepKinematics_adPositiveOnly; + else if (strcmp(text, ".NEGATIVE_ONLY.")) aTZ = StepKinematics_adNegativeOnly; + else if (strcmp(text, ".NOT_ACTUATED.")) aTZ = StepKinematics_adNotActuated; + else theArch->AddFail("Parameter #9 (t_z) has not allowed value"); + } + else theArch->AddFail("Parameter #9 (t_z) is not enumeration"); + } + else { + hasTZ = Standard_False; + } + + StepKinematics_ActuatedDirection aRX = StepKinematics_adNotActuated; + Standard_Boolean hasRX = Standard_True; + if ( theData->IsParamDefined (theNum,10) ) { + if (theData->ParamType (theNum, 10) == Interface_ParamEnum) { + Standard_CString text = theData->ParamCValue(theNum, 10); + if (strcmp(text, ".BIDIRECTIONAL.")) aRX = StepKinematics_adBidirectional; + else if (strcmp(text, ".POSITIVE_ONLY.")) aRX = StepKinematics_adPositiveOnly; + else if (strcmp(text, ".NEGATIVE_ONLY.")) aRX = StepKinematics_adNegativeOnly; + else if (strcmp(text, ".NOT_ACTUATED.")) aRX = StepKinematics_adNotActuated; + else theArch->AddFail("Parameter #10 (r_x) has not allowed value"); + } + else theArch->AddFail("Parameter #10 (r_x) is not enumeration"); + } + else { + hasRX = Standard_False; + } + + StepKinematics_ActuatedDirection aRY = StepKinematics_adNotActuated; + Standard_Boolean hasRY = Standard_True; + if ( theData->IsParamDefined (theNum,11) ) { + if (theData->ParamType (theNum, 11) == Interface_ParamEnum) { + Standard_CString text = theData->ParamCValue(theNum, 11); + if (strcmp(text, ".BIDIRECTIONAL.")) aRY = StepKinematics_adBidirectional; + else if (strcmp(text, ".POSITIVE_ONLY.")) aRY = StepKinematics_adPositiveOnly; + else if (strcmp(text, ".NEGATIVE_ONLY.")) aRY = StepKinematics_adNegativeOnly; + else if (strcmp(text, ".NOT_ACTUATED.")) aRY = StepKinematics_adNotActuated; + else theArch->AddFail("Parameter #11 (r_y) has not allowed value"); + } + else theArch->AddFail("Parameter #11 (r_y) is not enumeration"); + } + else { + hasRY = Standard_False; + } + + StepKinematics_ActuatedDirection aRZ = StepKinematics_adNotActuated; + Standard_Boolean hasRZ = Standard_True; + if ( theData->IsParamDefined (theNum,12) ) { + if (theData->ParamType (theNum, 12) == Interface_ParamEnum) { + Standard_CString text = theData->ParamCValue(theNum, 12); + if (strcmp(text, ".BIDIRECTIONAL.")) aRZ = StepKinematics_adBidirectional; + else if (strcmp(text, ".POSITIVE_ONLY.")) aRZ = StepKinematics_adPositiveOnly; + else if (strcmp(text, ".NEGATIVE_ONLY.")) aRZ = StepKinematics_adNegativeOnly; + else if (strcmp(text, ".NOT_ACTUATED.")) aRZ = StepKinematics_adNotActuated; + else theArch->AddFail("Parameter #12 (r_z) has not allowed value"); + } + else theArch->AddFail("Parameter #12 (r_z) is not enumeration"); + } + else { + hasRZ = Standard_False; + } + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + hasTX, + aTX, + hasTY, + aTY, + hasTZ, + aTZ, + hasRX, + aRX, + hasRY, + aRY, + hasRZ, + aRZ); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWActuatedKinematicPair::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_ActuatedKinematicPair)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of ActuatedKinematicPair + + if ( theEnt->HasTX() ) { + switch (theEnt->TX()) { + case StepKinematics_adBidirectional: theSW.SendEnum (".BIDIRECTIONAL."); break; + case StepKinematics_adPositiveOnly: theSW.SendEnum (".POSITIVE_ONLY."); break; + case StepKinematics_adNegativeOnly: theSW.SendEnum (".NEGATIVE_ONLY."); break; + case StepKinematics_adNotActuated: theSW.SendEnum (".NOT_ACTUATED."); break; + } + } + else theSW.SendUndef(); + + if ( theEnt->HasTY() ) { + switch (theEnt->TY()) { + case StepKinematics_adBidirectional: theSW.SendEnum (".BIDIRECTIONAL."); break; + case StepKinematics_adPositiveOnly: theSW.SendEnum (".POSITIVE_ONLY."); break; + case StepKinematics_adNegativeOnly: theSW.SendEnum (".NEGATIVE_ONLY."); break; + case StepKinematics_adNotActuated: theSW.SendEnum (".NOT_ACTUATED."); break; + } + } + else theSW.SendUndef(); + + if ( theEnt->HasTZ() ) { + switch (theEnt->TZ()) { + case StepKinematics_adBidirectional: theSW.SendEnum (".BIDIRECTIONAL."); break; + case StepKinematics_adPositiveOnly: theSW.SendEnum (".POSITIVE_ONLY."); break; + case StepKinematics_adNegativeOnly: theSW.SendEnum (".NEGATIVE_ONLY."); break; + case StepKinematics_adNotActuated: theSW.SendEnum (".NOT_ACTUATED."); break; + } + } + else theSW.SendUndef(); + + if ( theEnt->HasRX() ) { + switch (theEnt->RX()) { + case StepKinematics_adBidirectional: theSW.SendEnum (".BIDIRECTIONAL."); break; + case StepKinematics_adPositiveOnly: theSW.SendEnum (".POSITIVE_ONLY."); break; + case StepKinematics_adNegativeOnly: theSW.SendEnum (".NEGATIVE_ONLY."); break; + case StepKinematics_adNotActuated: theSW.SendEnum (".NOT_ACTUATED."); break; + } + } + else theSW.SendUndef(); + + if ( theEnt->HasRY() ) { + switch (theEnt->RY()) { + case StepKinematics_adBidirectional: theSW.SendEnum (".BIDIRECTIONAL."); break; + case StepKinematics_adPositiveOnly: theSW.SendEnum (".POSITIVE_ONLY."); break; + case StepKinematics_adNegativeOnly: theSW.SendEnum (".NEGATIVE_ONLY."); break; + case StepKinematics_adNotActuated: theSW.SendEnum (".NOT_ACTUATED."); break; + } + } + else theSW.SendUndef(); + + if ( theEnt->HasRZ() ) { + switch (theEnt->RZ()) { + case StepKinematics_adBidirectional: theSW.SendEnum (".BIDIRECTIONAL."); break; + case StepKinematics_adPositiveOnly: theSW.SendEnum (".POSITIVE_ONLY."); break; + case StepKinematics_adNegativeOnly: theSW.SendEnum (".NEGATIVE_ONLY."); break; + case StepKinematics_adNotActuated: theSW.SendEnum (".NOT_ACTUATED."); break; + } + } + else theSW.SendUndef(); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWActuatedKinematicPair::Share (const Handle(StepKinematics_ActuatedKinematicPair)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Own fields of ActuatedKinematicPair +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWActuatedKinematicPair.hxx b/src/RWStepKinematics/RWStepKinematics_RWActuatedKinematicPair.hxx new file mode 100644 index 0000000000..353c7e9813 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWActuatedKinematicPair.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWActuatedKinematicPair_HeaderFile_ +#define _RWStepKinematics_RWActuatedKinematicPair_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_ActuatedKinematicPair)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_ActuatedKinematicPair)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_ActuatedKinematicPair)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWActuatedKinematicPair_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWContextDependentKinematicLinkRepresentation.cxx b/src/RWStepKinematics/RWStepKinematics_RWContextDependentKinematicLinkRepresentation.cxx new file mode 100644 index 0000000000..104f157268 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWContextDependentKinematicLinkRepresentation.cxx @@ -0,0 +1,86 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_ContextDependentKinematicLinkRepresentation)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,2,theArch,"context_dependent_kinematic_link_representation") ) return; + + // Own fields of ContextDependentKinematicLinkRepresentation + + Handle(StepKinematics_KinematicLinkRepresentationAssociation) aRepresentationRelation; + theData->ReadEntity (theNum, 1, "representation_relation", theArch, STANDARD_TYPE(StepKinematics_KinematicLinkRepresentationAssociation), aRepresentationRelation); + + Handle(StepKinematics_ProductDefinitionRelationshipKinematics) aRepresentedProductRelation; + theData->ReadEntity (theNum, 2, "represented_product_relation", theArch, STANDARD_TYPE(StepKinematics_ProductDefinitionRelationshipKinematics), aRepresentedProductRelation); + + // Initialize entity + theEnt->Init(aRepresentationRelation, + aRepresentedProductRelation); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWContextDependentKinematicLinkRepresentation::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_ContextDependentKinematicLinkRepresentation)& theEnt) const +{ + + // Own fields of ContextDependentKinematicLinkRepresentation + + theSW.Send (theEnt->RepresentationRelation()); + + theSW.Send (theEnt->RepresentedProductRelation()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWContextDependentKinematicLinkRepresentation::Share (const Handle(StepKinematics_ContextDependentKinematicLinkRepresentation)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Own fields of ContextDependentKinematicLinkRepresentation + + iter.AddItem (theEnt->RepresentationRelation()); + + iter.AddItem (theEnt->RepresentedProductRelation()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWContextDependentKinematicLinkRepresentation.hxx b/src/RWStepKinematics/RWStepKinematics_RWContextDependentKinematicLinkRepresentation.hxx new file mode 100644 index 0000000000..f905b20aed --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWContextDependentKinematicLinkRepresentation.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWContextDependentKinematicLinkRepresentation_HeaderFile_ +#define _RWStepKinematics_RWContextDependentKinematicLinkRepresentation_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_ContextDependentKinematicLinkRepresentation)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_ContextDependentKinematicLinkRepresentation)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_ContextDependentKinematicLinkRepresentation)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWContextDependentKinematicLinkRepresentation_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWCylindricalPair.cxx b/src/RWStepKinematics/RWStepKinematics_RWCylindricalPair.cxx new file mode 100644 index 0000000000..23a0f027d5 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWCylindricalPair.cxx @@ -0,0 +1,180 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_CylindricalPair)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,12,theArch,"cylindrical_pair") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of LowOrderKinematicPair + + Standard_Boolean aLowOrderKinematicPair_TX; + theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX); + + Standard_Boolean aLowOrderKinematicPair_TY; + theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY); + + Standard_Boolean aLowOrderKinematicPair_TZ; + theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ); + + Standard_Boolean aLowOrderKinematicPair_RX; + theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX); + + Standard_Boolean aLowOrderKinematicPair_RY; + theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY); + + Standard_Boolean aLowOrderKinematicPair_RZ; + theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWCylindricalPair::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_CylindricalPair)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of LowOrderKinematicPair + + theSW.SendBoolean (theEnt->TX()); + + theSW.SendBoolean (theEnt->TY()); + + theSW.SendBoolean (theEnt->TZ()); + + theSW.SendBoolean (theEnt->RX()); + + theSW.SendBoolean (theEnt->RY()); + + theSW.SendBoolean (theEnt->RZ()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWCylindricalPair::Share (const Handle(StepKinematics_CylindricalPair)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of LowOrderKinematicPair +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWCylindricalPair.hxx b/src/RWStepKinematics/RWStepKinematics_RWCylindricalPair.hxx new file mode 100644 index 0000000000..bccc2d4764 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWCylindricalPair.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWCylindricalPair_HeaderFile_ +#define _RWStepKinematics_RWCylindricalPair_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_CylindricalPair)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_CylindricalPair)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_CylindricalPair)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWCylindricalPair_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWCylindricalPairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWCylindricalPairValue.cxx new file mode 100644 index 0000000000..3b7583aa2c --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWCylindricalPairValue.cxx @@ -0,0 +1,109 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_CylindricalPairValue)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,4,theArch,"cylindrical_pair_value") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of PairValue + + Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair; + theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair); + + // Own fields of CylindricalPairValue + + Standard_Real aActualTranslation; + theData->ReadReal (theNum, 3, "actual_translation", theArch, aActualTranslation); + + Standard_Real aActualRotation; + theData->ReadReal (theNum, 4, "actual_rotation", theArch, aActualRotation); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aPairValue_AppliesToPair, + aActualTranslation, + aActualRotation); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWCylindricalPairValue::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_CylindricalPairValue)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Own fields of PairValue + + theSW.Send (theEnt->AppliesToPair()); + + // Own fields of CylindricalPairValue + + theSW.Send (theEnt->ActualTranslation()); + + theSW.Send (theEnt->ActualRotation()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWCylindricalPairValue::Share (const Handle(StepKinematics_CylindricalPairValue)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of PairValue + + iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair()); + + // Own fields of CylindricalPairValue +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWCylindricalPairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWCylindricalPairValue.hxx new file mode 100644 index 0000000000..c4449c6dac --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWCylindricalPairValue.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWCylindricalPairValue_HeaderFile_ +#define _RWStepKinematics_RWCylindricalPairValue_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_CylindricalPairValue)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_CylindricalPairValue)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_CylindricalPairValue)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWCylindricalPairValue_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWCylindricalPairWithRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWCylindricalPairWithRange.cxx new file mode 100644 index 0000000000..b31ac4ff3a --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWCylindricalPairWithRange.cxx @@ -0,0 +1,255 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_CylindricalPairWithRange)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,16,theArch,"cylindrical_pair_with_range") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of LowOrderKinematicPair + + Standard_Boolean aLowOrderKinematicPair_TX; + theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX); + + Standard_Boolean aLowOrderKinematicPair_TY; + theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY); + + Standard_Boolean aLowOrderKinematicPair_TZ; + theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ); + + Standard_Boolean aLowOrderKinematicPair_RX; + theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX); + + Standard_Boolean aLowOrderKinematicPair_RY; + theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY); + + Standard_Boolean aLowOrderKinematicPair_RZ; + theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ); + + // Own fields of CylindricalPairWithRange + + Standard_Real aLowerLimitActualTranslation; + Standard_Boolean hasLowerLimitActualTranslation = Standard_True; + if ( theData->IsParamDefined (theNum,13) ) { + theData->ReadReal (theNum, 13, "lower_limit_actual_translation", theArch, aLowerLimitActualTranslation); + } + else { + hasLowerLimitActualTranslation = Standard_False; + aLowerLimitActualTranslation = 0; + } + + Standard_Real aUpperLimitActualTranslation; + Standard_Boolean hasUpperLimitActualTranslation = Standard_True; + if ( theData->IsParamDefined (theNum,14) ) { + theData->ReadReal (theNum, 14, "upper_limit_actual_translation", theArch, aUpperLimitActualTranslation); + } + else { + hasUpperLimitActualTranslation = Standard_False; + aUpperLimitActualTranslation = 0; + } + + Standard_Real aLowerLimitActualRotation; + Standard_Boolean hasLowerLimitActualRotation = Standard_True; + if ( theData->IsParamDefined (theNum,15) ) { + theData->ReadReal (theNum, 15, "lower_limit_actual_rotation", theArch, aLowerLimitActualRotation); + } + else { + hasLowerLimitActualRotation = Standard_False; + aLowerLimitActualRotation = 0; + } + + Standard_Real aUpperLimitActualRotation; + Standard_Boolean hasUpperLimitActualRotation = Standard_True; + if ( theData->IsParamDefined (theNum,16) ) { + theData->ReadReal (theNum, 16, "upper_limit_actual_rotation", theArch, aUpperLimitActualRotation); + } + else { + hasUpperLimitActualRotation = Standard_False; + aUpperLimitActualRotation = 0; + } + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ, + hasLowerLimitActualTranslation, + aLowerLimitActualTranslation, + hasUpperLimitActualTranslation, + aUpperLimitActualTranslation, + hasLowerLimitActualRotation, + aLowerLimitActualRotation, + hasUpperLimitActualRotation, + aUpperLimitActualRotation); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWCylindricalPairWithRange::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_CylindricalPairWithRange)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of LowOrderKinematicPair + + theSW.SendBoolean (theEnt->TX()); + + theSW.SendBoolean (theEnt->TY()); + + theSW.SendBoolean (theEnt->TZ()); + + theSW.SendBoolean (theEnt->RX()); + + theSW.SendBoolean (theEnt->RY()); + + theSW.SendBoolean (theEnt->RZ()); + + // Own fields of CylindricalPairWithRange + + if ( theEnt->HasLowerLimitActualTranslation() ) { + theSW.Send (theEnt->LowerLimitActualTranslation()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitActualTranslation() ) { + theSW.Send (theEnt->UpperLimitActualTranslation()); + } + else theSW.SendUndef(); + + if ( theEnt->HasLowerLimitActualRotation() ) { + theSW.Send (theEnt->LowerLimitActualRotation()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitActualRotation() ) { + theSW.Send (theEnt->UpperLimitActualRotation()); + } + else theSW.SendUndef(); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWCylindricalPairWithRange::Share (const Handle(StepKinematics_CylindricalPairWithRange)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of LowOrderKinematicPair + + // Own fields of CylindricalPairWithRange +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWCylindricalPairWithRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWCylindricalPairWithRange.hxx new file mode 100644 index 0000000000..a547f407c1 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWCylindricalPairWithRange.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWCylindricalPairWithRange_HeaderFile_ +#define _RWStepKinematics_RWCylindricalPairWithRange_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_CylindricalPairWithRange)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_CylindricalPairWithRange)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_CylindricalPairWithRange)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWCylindricalPairWithRange_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWFullyConstrainedPair.cxx b/src/RWStepKinematics/RWStepKinematics_RWFullyConstrainedPair.cxx new file mode 100644 index 0000000000..5d39829c2e --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWFullyConstrainedPair.cxx @@ -0,0 +1,180 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_FullyConstrainedPair)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,12,theArch,"fully_constrained_pair") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of LowOrderKinematicPair + + Standard_Boolean aLowOrderKinematicPair_TX; + theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX); + + Standard_Boolean aLowOrderKinematicPair_TY; + theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY); + + Standard_Boolean aLowOrderKinematicPair_TZ; + theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ); + + Standard_Boolean aLowOrderKinematicPair_RX; + theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX); + + Standard_Boolean aLowOrderKinematicPair_RY; + theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY); + + Standard_Boolean aLowOrderKinematicPair_RZ; + theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWFullyConstrainedPair::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_FullyConstrainedPair)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of LowOrderKinematicPair + + theSW.SendBoolean (theEnt->TX()); + + theSW.SendBoolean (theEnt->TY()); + + theSW.SendBoolean (theEnt->TZ()); + + theSW.SendBoolean (theEnt->RX()); + + theSW.SendBoolean (theEnt->RY()); + + theSW.SendBoolean (theEnt->RZ()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWFullyConstrainedPair::Share (const Handle(StepKinematics_FullyConstrainedPair)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of LowOrderKinematicPair +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWFullyConstrainedPair.hxx b/src/RWStepKinematics/RWStepKinematics_RWFullyConstrainedPair.hxx new file mode 100644 index 0000000000..0ea24d8f50 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWFullyConstrainedPair.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWFullyConstrainedPair_HeaderFile_ +#define _RWStepKinematics_RWFullyConstrainedPair_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_FullyConstrainedPair)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_FullyConstrainedPair)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_FullyConstrainedPair)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWFullyConstrainedPair_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWGearPair.cxx b/src/RWStepKinematics/RWStepKinematics_RWGearPair.cxx new file mode 100644 index 0000000000..3aa037d18b --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWGearPair.cxx @@ -0,0 +1,174 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_GearPair)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,11,theArch,"gear_pair") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Own fields of GearPair + + Standard_Real aRadiusFirstLink; + theData->ReadReal (theNum, 7, "radius_first_link", theArch, aRadiusFirstLink); + + Standard_Real aRadiusSecondLink; + theData->ReadReal (theNum, 8, "radius_second_link", theArch, aRadiusSecondLink); + + Standard_Real aBevel; + theData->ReadReal (theNum, 9, "bevel", theArch, aBevel); + + Standard_Real aHelicalAngle; + theData->ReadReal (theNum, 10, "helical_angle", theArch, aHelicalAngle); + + Standard_Real aGearRatio; + theData->ReadReal (theNum, 11, "gear_ratio", theArch, aGearRatio); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aRadiusFirstLink, + aRadiusSecondLink, + aBevel, + aHelicalAngle, + aGearRatio); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWGearPair::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_GearPair)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of GearPair + + theSW.Send (theEnt->RadiusFirstLink()); + + theSW.Send (theEnt->RadiusSecondLink()); + + theSW.Send (theEnt->Bevel()); + + theSW.Send (theEnt->HelicalAngle()); + + theSW.Send (theEnt->GearRatio()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWGearPair::Share (const Handle(StepKinematics_GearPair)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Own fields of GearPair +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWGearPair.hxx b/src/RWStepKinematics/RWStepKinematics_RWGearPair.hxx new file mode 100644 index 0000000000..925939954c --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWGearPair.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWGearPair_HeaderFile_ +#define _RWStepKinematics_RWGearPair_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_GearPair)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_GearPair)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_GearPair)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWGearPair_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWGearPairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWGearPairValue.cxx new file mode 100644 index 0000000000..74715d5a7e --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWGearPairValue.cxx @@ -0,0 +1,103 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_GearPairValue)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,3,theArch,"gear_pair_value") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of PairValue + + Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair; + theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair); + + // Own fields of GearPairValue + + Standard_Real aActualRotation1; + theData->ReadReal (theNum, 3, "actual_rotation1", theArch, aActualRotation1); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aPairValue_AppliesToPair, + aActualRotation1); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWGearPairValue::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_GearPairValue)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Own fields of PairValue + + theSW.Send (theEnt->AppliesToPair()); + + // Own fields of GearPairValue + + theSW.Send (theEnt->ActualRotation1()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWGearPairValue::Share (const Handle(StepKinematics_GearPairValue)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of PairValue + + iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair()); + + // Own fields of GearPairValue +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWGearPairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWGearPairValue.hxx new file mode 100644 index 0000000000..9e1fe2b871 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWGearPairValue.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWGearPairValue_HeaderFile_ +#define _RWStepKinematics_RWGearPairValue_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_GearPairValue)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_GearPairValue)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_GearPairValue)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWGearPairValue_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWGearPairWithRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWGearPairWithRange.cxx new file mode 100644 index 0000000000..292f3aa3f6 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWGearPairWithRange.cxx @@ -0,0 +1,214 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_GearPairWithRange)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,13,theArch,"gear_pair_with_range") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of GearPair + + Standard_Real aGearPair_RadiusFirstLink; + theData->ReadReal (theNum, 7, "gear_pair.radius_first_link", theArch, aGearPair_RadiusFirstLink); + + Standard_Real aGearPair_RadiusSecondLink; + theData->ReadReal (theNum, 8, "gear_pair.radius_second_link", theArch, aGearPair_RadiusSecondLink); + + Standard_Real aGearPair_Bevel; + theData->ReadReal (theNum, 9, "gear_pair.bevel", theArch, aGearPair_Bevel); + + Standard_Real aGearPair_HelicalAngle; + theData->ReadReal (theNum, 10, "gear_pair.helical_angle", theArch, aGearPair_HelicalAngle); + + Standard_Real aGearPair_GearRatio; + theData->ReadReal (theNum, 11, "gear_pair.gear_ratio", theArch, aGearPair_GearRatio); + + // Own fields of GearPairWithRange + + Standard_Real aLowerLimitActualRotation1; + Standard_Boolean hasLowerLimitActualRotation1 = Standard_True; + if ( theData->IsParamDefined (theNum,12) ) { + theData->ReadReal (theNum, 12, "lower_limit_actual_rotation1", theArch, aLowerLimitActualRotation1); + } + else { + hasLowerLimitActualRotation1 = Standard_False; + aLowerLimitActualRotation1 = 0; + } + + Standard_Real aUpperLimitActualRotation1; + Standard_Boolean hasUpperLimitActualRotation1 = Standard_True; + if ( theData->IsParamDefined (theNum,13) ) { + theData->ReadReal (theNum, 13, "upper_limit_actual_rotation1", theArch, aUpperLimitActualRotation1); + } + else { + hasUpperLimitActualRotation1 = Standard_False; + aUpperLimitActualRotation1 = 0; + } + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aGearPair_RadiusFirstLink, + aGearPair_RadiusSecondLink, + aGearPair_Bevel, + aGearPair_HelicalAngle, + aGearPair_GearRatio, + hasLowerLimitActualRotation1, + aLowerLimitActualRotation1, + hasUpperLimitActualRotation1, + aUpperLimitActualRotation1); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWGearPairWithRange::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_GearPairWithRange)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of GearPair + + theSW.Send (theEnt->RadiusFirstLink()); + + theSW.Send (theEnt->RadiusSecondLink()); + + theSW.Send (theEnt->Bevel()); + + theSW.Send (theEnt->HelicalAngle()); + + theSW.Send (theEnt->GearRatio()); + + // Own fields of GearPairWithRange + + if ( theEnt->HasLowerLimitActualRotation1() ) { + theSW.Send (theEnt->LowerLimitActualRotation1()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitActualRotation1() ) { + theSW.Send (theEnt->UpperLimitActualRotation1()); + } + else theSW.SendUndef(); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWGearPairWithRange::Share (const Handle(StepKinematics_GearPairWithRange)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of GearPair + + // Own fields of GearPairWithRange +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWGearPairWithRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWGearPairWithRange.hxx new file mode 100644 index 0000000000..ae79708ced --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWGearPairWithRange.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWGearPairWithRange_HeaderFile_ +#define _RWStepKinematics_RWGearPairWithRange_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_GearPairWithRange)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_GearPairWithRange)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_GearPairWithRange)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWGearPairWithRange_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWHomokineticPair.cxx b/src/RWStepKinematics/RWStepKinematics_RWHomokineticPair.cxx new file mode 100644 index 0000000000..e0309dc5dd --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWHomokineticPair.cxx @@ -0,0 +1,204 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_HomokineticPair)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,13,theArch,"homokinetic_pair") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of LowOrderKinematicPair + + Standard_Boolean aLowOrderKinematicPair_TX; + theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX); + + Standard_Boolean aLowOrderKinematicPair_TY; + theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY); + + Standard_Boolean aLowOrderKinematicPair_TZ; + theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ); + + Standard_Boolean aLowOrderKinematicPair_RX; + theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX); + + Standard_Boolean aLowOrderKinematicPair_RY; + theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY); + + Standard_Boolean aLowOrderKinematicPair_RZ; + theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ); + + // Inherited fields of UniversalPair + + Standard_Real aUniversalPair_InputSkewAngle; + Standard_Boolean hasUniversalPair_InputSkewAngle = Standard_True; + if ( theData->IsParamDefined (theNum,13) ) { + theData->ReadReal (theNum, 13, "universal_pair.input_skew_angle", theArch, aUniversalPair_InputSkewAngle); + } + else { + hasUniversalPair_InputSkewAngle = Standard_False; + aUniversalPair_InputSkewAngle = 0; + } + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ, + hasUniversalPair_InputSkewAngle, + aUniversalPair_InputSkewAngle); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWHomokineticPair::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_HomokineticPair)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of LowOrderKinematicPair + + theSW.SendBoolean (theEnt->TX()); + + theSW.SendBoolean (theEnt->TY()); + + theSW.SendBoolean (theEnt->TZ()); + + theSW.SendBoolean (theEnt->RX()); + + theSW.SendBoolean (theEnt->RY()); + + theSW.SendBoolean (theEnt->RZ()); + + // Own fields of UniversalPair + + if ( theEnt->HasInputSkewAngle() ) { + theSW.Send (theEnt->InputSkewAngle()); + } + else theSW.SendUndef(); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWHomokineticPair::Share (const Handle(StepKinematics_HomokineticPair)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of LowOrderKinematicPair + + // Inherited fields of UniversalPair +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWHomokineticPair.hxx b/src/RWStepKinematics/RWStepKinematics_RWHomokineticPair.hxx new file mode 100644 index 0000000000..53146bb6a5 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWHomokineticPair.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWHomokineticPair_HeaderFile_ +#define _RWStepKinematics_RWHomokineticPair_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_HomokineticPair)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_HomokineticPair)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_HomokineticPair)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWHomokineticPair_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWKinematicJoint.cxx b/src/RWStepKinematics/RWStepKinematics_RWKinematicJoint.cxx new file mode 100644 index 0000000000..32e7db487b --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWKinematicJoint.cxx @@ -0,0 +1,98 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_KinematicJoint)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,3,theArch,"kinematic_joint") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of Edge + + Handle(StepShape_Vertex) aEdge_EdgeStart; + theData->ReadEntity (theNum, 2, "edge.edge_start", theArch, STANDARD_TYPE(StepShape_Vertex), aEdge_EdgeStart); + + Handle(StepShape_Vertex) aEdge_EdgeEnd; + theData->ReadEntity (theNum, 3, "edge.edge_end", theArch, STANDARD_TYPE(StepShape_Vertex), aEdge_EdgeEnd); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aEdge_EdgeStart, + aEdge_EdgeEnd); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWKinematicJoint::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_KinematicJoint)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Own fields of Edge + + theSW.Send (theEnt->EdgeStart()); + + theSW.Send (theEnt->EdgeEnd()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWKinematicJoint::Share (const Handle(StepKinematics_KinematicJoint)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of Edge + + iter.AddItem (theEnt->StepShape_Edge::EdgeStart()); + + iter.AddItem (theEnt->StepShape_Edge::EdgeEnd()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWKinematicJoint.hxx b/src/RWStepKinematics/RWStepKinematics_RWKinematicJoint.hxx new file mode 100644 index 0000000000..9b7cc9952c --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWKinematicJoint.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWKinematicJoint_HeaderFile_ +#define _RWStepKinematics_RWKinematicJoint_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_KinematicJoint)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_KinematicJoint)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_KinematicJoint)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWKinematicJoint_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWKinematicLink.cxx b/src/RWStepKinematics/RWStepKinematics_RWKinematicLink.cxx new file mode 100644 index 0000000000..688ed56b8e --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWKinematicLink.cxx @@ -0,0 +1,75 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#include +#include +#include +#include +#include + +//======================================================================= +//function : RWStepKinematics_RWKinematicLink +//purpose : +//======================================================================= +RWStepKinematics_RWKinematicLink::RWStepKinematics_RWKinematicLink() {} + + +//======================================================================= +//function : ReadStep +//purpose : +//======================================================================= +void RWStepKinematics_RWKinematicLink::ReadStep (const Handle(StepData_StepReaderData)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_KinematicLink)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,1,theArch,"kinematic_link") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWKinematicLink::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_KinematicLink)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWKinematicLink::Share (const Handle(StepKinematics_KinematicLink)& /*theEnt*/, + Interface_EntityIterator& /*iter*/) const +{ + + // Inherited fields of RepresentationItem +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWKinematicLink.hxx b/src/RWStepKinematics/RWStepKinematics_RWKinematicLink.hxx new file mode 100644 index 0000000000..65dc3ef165 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWKinematicLink.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWKinematicLink_HeaderFile_ +#define _RWStepKinematics_RWKinematicLink_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_KinematicLink)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_KinematicLink)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_KinematicLink)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWKinematicLink_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWKinematicLinkRepresentationAssociation.cxx b/src/RWStepKinematics/RWStepKinematics_RWKinematicLinkRepresentationAssociation.cxx new file mode 100644 index 0000000000..26d87cb2af --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWKinematicLinkRepresentationAssociation.cxx @@ -0,0 +1,111 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_KinematicLinkRepresentationAssociation)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,4,theArch,"kinematic_link_representation_association") ) return; + + // Inherited fields of RepresentationRelationship + + Handle(TCollection_HAsciiString) aRepresentationRelationship_Name; + theData->ReadString (theNum, 1, "representation_relationship.name", theArch, aRepresentationRelationship_Name); + + Handle(TCollection_HAsciiString) aRepresentationRelationship_Description; + if ( theData->IsParamDefined (theNum,2) ) { + theData->ReadString (theNum, 2, "representation_relationship.description", theArch, aRepresentationRelationship_Description); + } + else { + aRepresentationRelationship_Description.Nullify(); + } + + StepRepr_RepresentationOrRepresentationReference aRepresentationRelationship_Rep1; + theData->ReadEntity (theNum, 3, "representation_relationship.rep1", theArch, aRepresentationRelationship_Rep1); + + StepRepr_RepresentationOrRepresentationReference aRepresentationRelationship_Rep2; + theData->ReadEntity (theNum, 4, "representation_relationship.rep2", theArch, aRepresentationRelationship_Rep2); + + // Process only one type (Representaion) + if (aRepresentationRelationship_Rep1.CaseNumber() != 1 || aRepresentationRelationship_Rep1.CaseNumber() != 1) + return; + + // Initialize entity + theEnt->Init(aRepresentationRelationship_Name, + aRepresentationRelationship_Description, + aRepresentationRelationship_Rep1.Representation(), + aRepresentationRelationship_Rep2.Representation()); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWKinematicLinkRepresentationAssociation::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_KinematicLinkRepresentationAssociation)& theEnt) const +{ + + // Own fields of RepresentationRelationship + + theSW.Send (theEnt->Name()); + + if ( theEnt->HasDescription() ) { + theSW.Send (theEnt->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->Rep1()); + + theSW.Send (theEnt->Rep2()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWKinematicLinkRepresentationAssociation::Share (const Handle(StepKinematics_KinematicLinkRepresentationAssociation)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationRelationship + + iter.AddItem (theEnt->StepRepr_RepresentationRelationship::Rep1()); + + iter.AddItem (theEnt->StepRepr_RepresentationRelationship::Rep2()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWKinematicLinkRepresentationAssociation.hxx b/src/RWStepKinematics/RWStepKinematics_RWKinematicLinkRepresentationAssociation.hxx new file mode 100644 index 0000000000..514bac06a3 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWKinematicLinkRepresentationAssociation.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWKinematicLinkRepresentationAssociation_HeaderFile_ +#define _RWStepKinematics_RWKinematicLinkRepresentationAssociation_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_KinematicLinkRepresentationAssociation)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_KinematicLinkRepresentationAssociation)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_KinematicLinkRepresentationAssociation)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWKinematicLinkRepresentationAssociation_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWKinematicPropertyMechanismRepresentation.cxx b/src/RWStepKinematics/RWStepKinematics_RWKinematicPropertyMechanismRepresentation.cxx new file mode 100644 index 0000000000..7108842ee2 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWKinematicPropertyMechanismRepresentation.cxx @@ -0,0 +1,101 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_KinematicPropertyMechanismRepresentation)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,3,theArch,"kinematic_property_mechanism_representation") ) return; + + // Inherited fields of PropertyDefinitionRepresentation + + StepRepr_RepresentedDefinition aPropertyDefinitionRepresentation_Definition; + theData->ReadEntity (theNum, 1, "property_definition_representation.definition", theArch, aPropertyDefinitionRepresentation_Definition); + + Handle(StepRepr_Representation) aPropertyDefinitionRepresentation_UsedRepresentation; + theData->ReadEntity (theNum, 2, "property_definition_representation.used_representation", theArch, STANDARD_TYPE(StepRepr_Representation), aPropertyDefinitionRepresentation_UsedRepresentation); + + // Own fields of KinematicPropertyMechanismRepresentation + + Handle(StepKinematics_KinematicLinkRepresentation) aBase; + theData->ReadEntity (theNum, 3, "base", theArch, STANDARD_TYPE(StepKinematics_KinematicLinkRepresentation), aBase); + + // Initialize entity + theEnt->Init(aPropertyDefinitionRepresentation_Definition, + aPropertyDefinitionRepresentation_UsedRepresentation, + aBase); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWKinematicPropertyMechanismRepresentation::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_KinematicPropertyMechanismRepresentation)& theEnt) const +{ + + // Own fields of PropertyDefinitionRepresentation + + theSW.Send (theEnt->Definition().Value()); + + theSW.Send (theEnt->UsedRepresentation()); + + // Own fields of KinematicPropertyMechanismRepresentation + + theSW.Send (theEnt->Base()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWKinematicPropertyMechanismRepresentation::Share (const Handle(StepKinematics_KinematicPropertyMechanismRepresentation)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of PropertyDefinitionRepresentation + + iter.AddItem (theEnt->StepRepr_PropertyDefinitionRepresentation::Definition().Value()); + + iter.AddItem (theEnt->StepRepr_PropertyDefinitionRepresentation::UsedRepresentation()); + + // Own fields of KinematicPropertyMechanismRepresentation + + iter.AddItem (theEnt->Base()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWKinematicPropertyMechanismRepresentation.hxx b/src/RWStepKinematics/RWStepKinematics_RWKinematicPropertyMechanismRepresentation.hxx new file mode 100644 index 0000000000..ca281d752e --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWKinematicPropertyMechanismRepresentation.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWKinematicPropertyMechanismRepresentation_HeaderFile_ +#define _RWStepKinematics_RWKinematicPropertyMechanismRepresentation_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_KinematicPropertyMechanismRepresentation)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_KinematicPropertyMechanismRepresentation)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_KinematicPropertyMechanismRepresentation)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWKinematicPropertyMechanismRepresentation_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyDirectedStructure.cxx b/src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyDirectedStructure.cxx new file mode 100644 index 0000000000..59021d0c79 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyDirectedStructure.cxx @@ -0,0 +1,127 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//function : RWStepKinematics_RWKinematicTopologyDirectedStructure +//purpose : +//======================================================================= +RWStepKinematics_RWKinematicTopologyDirectedStructure::RWStepKinematics_RWKinematicTopologyDirectedStructure() {} + + +//======================================================================= +//function : ReadStep +//purpose : +//======================================================================= +void RWStepKinematics_RWKinematicTopologyDirectedStructure::ReadStep (const Handle(StepData_StepReaderData)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_KinematicTopologyDirectedStructure)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,4,theArch,"kinematic_topology_directed_structure") ) return; + + // Inherited fields of Representation + + Handle(TCollection_HAsciiString) aRepresentation_Name; + theData->ReadString (theNum, 1, "representation.name", theArch, aRepresentation_Name); + + Handle(StepRepr_HArray1OfRepresentationItem) aRepresentation_Items; + Standard_Integer sub2 = 0; + if ( theData->ReadSubList (theNum, 2, "representation.items", theArch, sub2) ) { + Standard_Integer nb0 = theData->NbParams(sub2); + aRepresentation_Items = new StepRepr_HArray1OfRepresentationItem (1, nb0); + Standard_Integer num2 = sub2; + for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) { + Handle(StepRepr_RepresentationItem) anIt0; + theData->ReadEntity (num2, i0, "representation_item", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), anIt0); + aRepresentation_Items->SetValue(i0, anIt0); + } + } + + Handle(StepRepr_RepresentationContext) aRepresentation_ContextOfItems; + theData->ReadEntity (theNum, 3, "representation.context_of_items", theArch, STANDARD_TYPE(StepRepr_RepresentationContext), aRepresentation_ContextOfItems); + + // Own fields of KinematicTopologyDirectedStructure + + Handle(StepKinematics_KinematicTopologyStructure) aParent; + theData->ReadEntity (theNum, 4, "parent", theArch, STANDARD_TYPE(StepKinematics_KinematicTopologyStructure), aParent); + + // Initialize entity + theEnt->Init(aRepresentation_Name, + aRepresentation_Items, + aRepresentation_ContextOfItems, + aParent); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWKinematicTopologyDirectedStructure::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_KinematicTopologyDirectedStructure)& theEnt) const +{ + + // Own fields of Representation + + theSW.Send (theEnt->Name()); + + theSW.OpenSub(); + for (Standard_Integer i1=1; i1 <= theEnt->Items()->Length(); i1++ ) { + Handle(StepRepr_RepresentationItem) Var0 = theEnt->Items()->Value(i1); + theSW.Send (Var0); + } + theSW.CloseSub(); + + theSW.Send (theEnt->ContextOfItems()); + + // Own fields of KinematicTopologyDirectedStructure + + theSW.Send (theEnt->Parent()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWKinematicTopologyDirectedStructure::Share (const Handle(StepKinematics_KinematicTopologyDirectedStructure)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of Representation + + for (Standard_Integer i1=1; i1 <= theEnt->StepRepr_Representation::Items()->Length(); i1++ ) { + Handle(StepRepr_RepresentationItem) Var0 = theEnt->StepRepr_Representation::Items()->Value(i1); + iter.AddItem (Var0); + } + + iter.AddItem (theEnt->StepRepr_Representation::ContextOfItems()); + + // Own fields of KinematicTopologyDirectedStructure + + iter.AddItem (theEnt->Parent()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyDirectedStructure.hxx b/src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyDirectedStructure.hxx new file mode 100644 index 0000000000..4aa061bc91 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyDirectedStructure.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWKinematicTopologyDirectedStructure_HeaderFile_ +#define _RWStepKinematics_RWKinematicTopologyDirectedStructure_HeaderFile_ + +#include +#include +#include + +class StepData_StepReaderData; +class Interface_Check; +class StepData_StepWriter; +class Interface_EntityIterator; +class StepKinematics_KinematicTopologyDirectedStructure; + +//! Read & Write tool for KinematicTopologyDirectedStructure +class RWStepKinematics_RWKinematicTopologyDirectedStructure +{ +public: + + DEFINE_STANDARD_ALLOC + + Standard_EXPORT RWStepKinematics_RWKinematicTopologyDirectedStructure(); + + Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_KinematicTopologyDirectedStructure)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_KinematicTopologyDirectedStructure)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_KinematicTopologyDirectedStructure)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWKinematicTopologyDirectedStructure_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyNetworkStructure.cxx b/src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyNetworkStructure.cxx new file mode 100644 index 0000000000..f1e11db7b8 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyNetworkStructure.cxx @@ -0,0 +1,127 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//function : RWStepKinematics_RWKinematicTopologyNetworkStructure +//purpose : +//======================================================================= +RWStepKinematics_RWKinematicTopologyNetworkStructure::RWStepKinematics_RWKinematicTopologyNetworkStructure() {} + + +//======================================================================= +//function : ReadStep +//purpose : +//======================================================================= +void RWStepKinematics_RWKinematicTopologyNetworkStructure::ReadStep (const Handle(StepData_StepReaderData)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_KinematicTopologyNetworkStructure)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,4,theArch,"kinematic_topology_network_structure") ) return; + + // Inherited fields of Representation + + Handle(TCollection_HAsciiString) aRepresentation_Name; + theData->ReadString (theNum, 1, "representation.name", theArch, aRepresentation_Name); + + Handle(StepRepr_HArray1OfRepresentationItem) aRepresentation_Items; + Standard_Integer sub2 = 0; + if ( theData->ReadSubList (theNum, 2, "representation.items", theArch, sub2) ) { + Standard_Integer nb0 = theData->NbParams(sub2); + aRepresentation_Items = new StepRepr_HArray1OfRepresentationItem (1, nb0); + Standard_Integer num2 = sub2; + for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) { + Handle(StepRepr_RepresentationItem) anIt0; + theData->ReadEntity (num2, i0, "representation_item", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), anIt0); + aRepresentation_Items->SetValue(i0, anIt0); + } + } + + Handle(StepRepr_RepresentationContext) aRepresentation_ContextOfItems; + theData->ReadEntity (theNum, 3, "representation.context_of_items", theArch, STANDARD_TYPE(StepRepr_RepresentationContext), aRepresentation_ContextOfItems); + + // Own fields of KinematicTopologyNetworkStructure + + Handle(StepKinematics_KinematicTopologyStructure) aParent; + theData->ReadEntity (theNum, 4, "parent", theArch, STANDARD_TYPE(StepKinematics_KinematicTopologyStructure), aParent); + + // Initialize entity + theEnt->Init(aRepresentation_Name, + aRepresentation_Items, + aRepresentation_ContextOfItems, + aParent); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWKinematicTopologyNetworkStructure::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_KinematicTopologyNetworkStructure)& theEnt) const +{ + + // Own fields of Representation + + theSW.Send (theEnt->Name()); + + theSW.OpenSub(); + for (Standard_Integer i1=1; i1 <= theEnt->Items()->Length(); i1++ ) { + Handle(StepRepr_RepresentationItem) Var0 = theEnt->Items()->Value(i1); + theSW.Send (Var0); + } + theSW.CloseSub(); + + theSW.Send (theEnt->ContextOfItems()); + + // Own fields of KinematicTopologyNetworkStructure + + theSW.Send (theEnt->Parent()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWKinematicTopologyNetworkStructure::Share (const Handle(StepKinematics_KinematicTopologyNetworkStructure)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of Representation + + for (Standard_Integer i1=1; i1 <= theEnt->StepRepr_Representation::Items()->Length(); i1++ ) { + Handle(StepRepr_RepresentationItem) Var0 = theEnt->StepRepr_Representation::Items()->Value(i1); + iter.AddItem (Var0); + } + + iter.AddItem (theEnt->StepRepr_Representation::ContextOfItems()); + + // Own fields of KinematicTopologyNetworkStructure + + iter.AddItem (theEnt->Parent()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyNetworkStructure.hxx b/src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyNetworkStructure.hxx new file mode 100644 index 0000000000..0bfa4bc559 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyNetworkStructure.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWKinematicTopologyNetworkStructure_HeaderFile_ +#define _RWStepKinematics_RWKinematicTopologyNetworkStructure_HeaderFile_ + +#include +#include +#include + +class StepData_StepReaderData; +class Interface_Check; +class StepData_StepWriter; +class Interface_EntityIterator; +class StepKinematics_KinematicTopologyNetworkStructure; + +//! Read & Write tool for KinematicTopologyNetworkStructure +class RWStepKinematics_RWKinematicTopologyNetworkStructure +{ +public: + + DEFINE_STANDARD_ALLOC + + Standard_EXPORT RWStepKinematics_RWKinematicTopologyNetworkStructure(); + + Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_KinematicTopologyNetworkStructure)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_KinematicTopologyNetworkStructure)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_KinematicTopologyNetworkStructure)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWKinematicTopologyNetworkStructure_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyStructure.cxx b/src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyStructure.cxx new file mode 100644 index 0000000000..25de7bd368 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyStructure.cxx @@ -0,0 +1,112 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_KinematicTopologyStructure)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,3,theArch,"kinematic_topology_structure") ) return; + + // Inherited fields of Representation + + Handle(TCollection_HAsciiString) aRepresentation_Name; + theData->ReadString (theNum, 1, "representation.name", theArch, aRepresentation_Name); + + Handle(StepRepr_HArray1OfRepresentationItem) aRepresentation_Items; + Standard_Integer sub2 = 0; + if ( theData->ReadSubList (theNum, 2, "representation.items", theArch, sub2) ) { + Standard_Integer nb0 = theData->NbParams(sub2); + aRepresentation_Items = new StepRepr_HArray1OfRepresentationItem (1, nb0); + Standard_Integer num2 = sub2; + for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) { + Handle(StepRepr_RepresentationItem) anIt0; + theData->ReadEntity (num2, i0, "representation_item", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), anIt0); + aRepresentation_Items->SetValue(i0, anIt0); + } + } + + Handle(StepRepr_RepresentationContext) aRepresentation_ContextOfItems; + theData->ReadEntity (theNum, 3, "representation.context_of_items", theArch, STANDARD_TYPE(StepRepr_RepresentationContext), aRepresentation_ContextOfItems); + + // Initialize entity + theEnt->Init(aRepresentation_Name, + aRepresentation_Items, + aRepresentation_ContextOfItems); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWKinematicTopologyStructure::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_KinematicTopologyStructure)& theEnt) const +{ + + // Own fields of Representation + + theSW.Send (theEnt->Name()); + + theSW.OpenSub(); + for (Standard_Integer i1=1; i1 <= theEnt->Items()->Length(); i1++ ) { + Handle(StepRepr_RepresentationItem) Var0 = theEnt->Items()->Value(i1); + theSW.Send (Var0); + } + theSW.CloseSub(); + + theSW.Send (theEnt->ContextOfItems()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWKinematicTopologyStructure::Share (const Handle(StepKinematics_KinematicTopologyStructure)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of Representation + + for (Standard_Integer i1=1; i1 <= theEnt->StepRepr_Representation::Items()->Length(); i1++ ) { + Handle(StepRepr_RepresentationItem) Var0 = theEnt->StepRepr_Representation::Items()->Value(i1); + iter.AddItem (Var0); + } + + iter.AddItem (theEnt->StepRepr_Representation::ContextOfItems()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyStructure.hxx b/src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyStructure.hxx new file mode 100644 index 0000000000..86643d4ea2 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyStructure.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWKinematicTopologyStructure_HeaderFile_ +#define _RWStepKinematics_RWKinematicTopologyStructure_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_KinematicTopologyStructure)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_KinematicTopologyStructure)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_KinematicTopologyStructure)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWKinematicTopologyStructure_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWLinearFlexibleAndPinionPair.cxx b/src/RWStepKinematics/RWStepKinematics_RWLinearFlexibleAndPinionPair.cxx new file mode 100644 index 0000000000..b6aca30c9c --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWLinearFlexibleAndPinionPair.cxx @@ -0,0 +1,150 @@ +// Created on : Fri May 08 19:02:07 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//function : RWStepKinematics_RWLinearFlexibleAndPinionPair +//purpose : +//======================================================================= +RWStepKinematics_RWLinearFlexibleAndPinionPair::RWStepKinematics_RWLinearFlexibleAndPinionPair() {} + + +//======================================================================= +//function : ReadStep +//purpose : +//======================================================================= +void RWStepKinematics_RWLinearFlexibleAndPinionPair::ReadStep (const Handle(StepData_StepReaderData)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_LinearFlexibleAndPinionPair)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,7,theArch,"linear_flexible_and_pinion_pair") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Own fields of LinearFlexibleAndPinionPair + + Standard_Real aPinionRadius; + theData->ReadReal (theNum, 7, "pinion_radius", theArch, aPinionRadius); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aPinionRadius); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWLinearFlexibleAndPinionPair::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_LinearFlexibleAndPinionPair)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of LinearFlexibleAndPinionPair + + theSW.Send (theEnt->PinionRadius()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWLinearFlexibleAndPinionPair::Share (const Handle(StepKinematics_LinearFlexibleAndPinionPair)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Own fields of LinearFlexibleAndPinionPair +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWLinearFlexibleAndPinionPair.hxx b/src/RWStepKinematics/RWStepKinematics_RWLinearFlexibleAndPinionPair.hxx new file mode 100644 index 0000000000..cc3d9125c9 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWLinearFlexibleAndPinionPair.hxx @@ -0,0 +1,46 @@ +// Created on : Fri May 08 19:02:07 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWLinearFlexibleAndPinionPair_HeaderFile_ +#define _RWStepKinematics_RWLinearFlexibleAndPinionPair_HeaderFile_ + +#include +#include +#include + +class StepData_StepReaderData; +class Interface_Check; +class StepData_StepWriter; +class Interface_EntityIterator; +class StepKinematics_LinearFlexibleAndPinionPair; + +//! Read & Write tool for LinearFlexibleAndPinionPair +class RWStepKinematics_RWLinearFlexibleAndPinionPair +{ +public: + + DEFINE_STANDARD_ALLOC + + Standard_EXPORT RWStepKinematics_RWLinearFlexibleAndPinionPair(); + + Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_LinearFlexibleAndPinionPair)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_LinearFlexibleAndPinionPair)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_LinearFlexibleAndPinionPair)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWLinearFlexibleAndPinionPair_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair.cxx b/src/RWStepKinematics/RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair.cxx new file mode 100644 index 0000000000..c3d1e3c645 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair.cxx @@ -0,0 +1,159 @@ +// Created on : Fri May 08 19:02:07 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//function : RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair +//purpose : +//======================================================================= +RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair::RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair() {} + + +//======================================================================= +//function : ReadStep +//purpose : +//======================================================================= +void RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair::ReadStep (const Handle(StepData_StepReaderData)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_LinearFlexibleAndPlanarCurvePair)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,8,theArch,"linear_flexible_and_planar_curve_pair") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Own fields of LinearFlexibleAndPlanarCurvePair + + Handle(StepGeom_Curve) aPairCurve; + theData->ReadEntity (theNum, 7, "pair_curve", theArch, STANDARD_TYPE(StepGeom_Curve), aPairCurve); + + Standard_Boolean aOrientation; + theData->ReadBoolean (theNum, 8, "orientation", theArch, aOrientation); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aPairCurve, + aOrientation); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_LinearFlexibleAndPlanarCurvePair)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of LinearFlexibleAndPlanarCurvePair + + theSW.Send (theEnt->PairCurve()); + + theSW.SendBoolean (theEnt->Orientation()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair::Share (const Handle(StepKinematics_LinearFlexibleAndPlanarCurvePair)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Own fields of LinearFlexibleAndPlanarCurvePair + + iter.AddItem (theEnt->PairCurve()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair.hxx b/src/RWStepKinematics/RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair.hxx new file mode 100644 index 0000000000..58d1582fc8 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair.hxx @@ -0,0 +1,46 @@ +// Created on : Fri May 08 19:02:07 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair_HeaderFile_ +#define _RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair_HeaderFile_ + +#include +#include +#include + +class StepData_StepReaderData; +class Interface_Check; +class StepData_StepWriter; +class Interface_EntityIterator; +class StepKinematics_LinearFlexibleAndPlanarCurvePair; + +//! Read & Write tool for LinearFlexibleAndPlanarCurvePair +class RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair +{ +public: + + DEFINE_STANDARD_ALLOC + + Standard_EXPORT RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair(); + + Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_LinearFlexibleAndPlanarCurvePair)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_LinearFlexibleAndPlanarCurvePair)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_LinearFlexibleAndPlanarCurvePair)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWLinearFlexibleLinkRepresentation.cxx b/src/RWStepKinematics/RWStepKinematics_RWLinearFlexibleLinkRepresentation.cxx new file mode 100644 index 0000000000..f73067b647 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWLinearFlexibleLinkRepresentation.cxx @@ -0,0 +1,127 @@ +// Created on : Fri May 08 19:02:07 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//function : RWStepKinematics_RWLinearFlexibleLinkRepresentation +//purpose : +//======================================================================= +RWStepKinematics_RWLinearFlexibleLinkRepresentation::RWStepKinematics_RWLinearFlexibleLinkRepresentation() {} + + +//======================================================================= +//function : ReadStep +//purpose : +//======================================================================= +void RWStepKinematics_RWLinearFlexibleLinkRepresentation::ReadStep (const Handle(StepData_StepReaderData)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_LinearFlexibleLinkRepresentation)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,4,theArch,"linear_flexible_link_representation") ) return; + + // Inherited fields of Representation + + Handle(TCollection_HAsciiString) aRepresentation_Name; + theData->ReadString (theNum, 1, "representation.name", theArch, aRepresentation_Name); + + Handle(StepRepr_HArray1OfRepresentationItem) aRepresentation_Items; + Standard_Integer sub2 = 0; + if ( theData->ReadSubList (theNum, 2, "representation.items", theArch, sub2) ) { + Standard_Integer nb0 = theData->NbParams(sub2); + aRepresentation_Items = new StepRepr_HArray1OfRepresentationItem (1, nb0); + Standard_Integer num2 = sub2; + for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) { + Handle(StepRepr_RepresentationItem) anIt0; + theData->ReadEntity (num2, i0, "representation_item", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), anIt0); + aRepresentation_Items->SetValue(i0, anIt0); + } + } + + Handle(StepRepr_RepresentationContext) aRepresentation_ContextOfItems; + theData->ReadEntity (theNum, 3, "representation.context_of_items", theArch, STANDARD_TYPE(StepRepr_RepresentationContext), aRepresentation_ContextOfItems); + + // Inherited fields of KinematicLinkRepresentation + + Handle(StepKinematics_KinematicLink) aKinematicLinkRepresentation_RepresentedLink; + theData->ReadEntity (theNum, 4, "kinematic_link_representation.represented_link", theArch, STANDARD_TYPE(StepKinematics_KinematicLink), aKinematicLinkRepresentation_RepresentedLink); + + // Initialize entity + theEnt->Init(aRepresentation_Name, + aRepresentation_Items, + aRepresentation_ContextOfItems, + aKinematicLinkRepresentation_RepresentedLink); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWLinearFlexibleLinkRepresentation::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_LinearFlexibleLinkRepresentation)& theEnt) const +{ + + // Own fields of Representation + + theSW.Send (theEnt->Name()); + + theSW.OpenSub(); + for (Standard_Integer i1=1; i1 <= theEnt->Items()->Length(); i1++ ) { + Handle(StepRepr_RepresentationItem) Var0 = theEnt->Items()->Value(i1); + theSW.Send (Var0); + } + theSW.CloseSub(); + + theSW.Send (theEnt->ContextOfItems()); + + // Own fields of KinematicLinkRepresentation + + theSW.Send (theEnt->RepresentedLink()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWLinearFlexibleLinkRepresentation::Share (const Handle(StepKinematics_LinearFlexibleLinkRepresentation)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of Representation + + for (Standard_Integer i1=1; i1 <= theEnt->StepRepr_Representation::Items()->Length(); i1++ ) { + Handle(StepRepr_RepresentationItem) Var0 = theEnt->StepRepr_Representation::Items()->Value(i1); + iter.AddItem (Var0); + } + + iter.AddItem (theEnt->StepRepr_Representation::ContextOfItems()); + + // Inherited fields of KinematicLinkRepresentation + + iter.AddItem (theEnt->StepKinematics_KinematicLinkRepresentation::RepresentedLink()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWLinearFlexibleLinkRepresentation.hxx b/src/RWStepKinematics/RWStepKinematics_RWLinearFlexibleLinkRepresentation.hxx new file mode 100644 index 0000000000..567e5a8c0e --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWLinearFlexibleLinkRepresentation.hxx @@ -0,0 +1,46 @@ +// Created on : Fri May 08 19:02:07 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWLinearFlexibleLinkRepresentation_HeaderFile_ +#define _RWStepKinematics_RWLinearFlexibleLinkRepresentation_HeaderFile_ + +#include +#include +#include + +class StepData_StepReaderData; +class Interface_Check; +class StepData_StepWriter; +class Interface_EntityIterator; +class StepKinematics_LinearFlexibleLinkRepresentation; + +//! Read & Write tool for LinearFlexibleLinkRepresentation +class RWStepKinematics_RWLinearFlexibleLinkRepresentation +{ +public: + + DEFINE_STANDARD_ALLOC + + Standard_EXPORT RWStepKinematics_RWLinearFlexibleLinkRepresentation(); + + Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_LinearFlexibleLinkRepresentation)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_LinearFlexibleLinkRepresentation)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_LinearFlexibleLinkRepresentation)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWLinearFlexibleLinkRepresentation_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPair.cxx b/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPair.cxx new file mode 100644 index 0000000000..599783cf4f --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPair.cxx @@ -0,0 +1,180 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_LowOrderKinematicPair)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,12,theArch,"low_order_kinematic_pair") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Own fields of LowOrderKinematicPair + + Standard_Boolean aTX; + theData->ReadBoolean (theNum, 7, "t_x", theArch, aTX); + + Standard_Boolean aTY; + theData->ReadBoolean (theNum, 8, "t_y", theArch, aTY); + + Standard_Boolean aTZ; + theData->ReadBoolean (theNum, 9, "t_z", theArch, aTZ); + + Standard_Boolean aRX; + theData->ReadBoolean (theNum, 10, "r_x", theArch, aRX); + + Standard_Boolean aRY; + theData->ReadBoolean (theNum, 11, "r_y", theArch, aRY); + + Standard_Boolean aRZ; + theData->ReadBoolean (theNum, 12, "r_z", theArch, aRZ); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aTX, + aTY, + aTZ, + aRX, + aRY, + aRZ); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWLowOrderKinematicPair::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_LowOrderKinematicPair)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of LowOrderKinematicPair + + theSW.SendBoolean (theEnt->TX()); + + theSW.SendBoolean (theEnt->TY()); + + theSW.SendBoolean (theEnt->TZ()); + + theSW.SendBoolean (theEnt->RX()); + + theSW.SendBoolean (theEnt->RY()); + + theSW.SendBoolean (theEnt->RZ()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWLowOrderKinematicPair::Share (const Handle(StepKinematics_LowOrderKinematicPair)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Own fields of LowOrderKinematicPair +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPair.hxx b/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPair.hxx new file mode 100644 index 0000000000..74e5a45880 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPair.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWLowOrderKinematicPair_HeaderFile_ +#define _RWStepKinematics_RWLowOrderKinematicPair_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_LowOrderKinematicPair)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_LowOrderKinematicPair)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_LowOrderKinematicPair)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWLowOrderKinematicPair_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPairValue.cxx new file mode 100644 index 0000000000..41a432b814 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPairValue.cxx @@ -0,0 +1,133 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_LowOrderKinematicPairValue)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,8,theArch,"low_order_kinematic_pair_value") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of PairValue + + Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair; + theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair); + + // Own fields of LowOrderKinematicPairValue + + Standard_Real aActualTranslationX; + theData->ReadReal (theNum, 3, "actual_translation_x", theArch, aActualTranslationX); + + Standard_Real aActualTranslationY; + theData->ReadReal (theNum, 4, "actual_translation_y", theArch, aActualTranslationY); + + Standard_Real aActualTranslationZ; + theData->ReadReal (theNum, 5, "actual_translation_z", theArch, aActualTranslationZ); + + Standard_Real aActualRotationX; + theData->ReadReal (theNum, 6, "actual_rotation_x", theArch, aActualRotationX); + + Standard_Real aActualRotationY; + theData->ReadReal (theNum, 7, "actual_rotation_y", theArch, aActualRotationY); + + Standard_Real aActualRotationZ; + theData->ReadReal (theNum, 8, "actual_rotation_z", theArch, aActualRotationZ); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aPairValue_AppliesToPair, + aActualTranslationX, + aActualTranslationY, + aActualTranslationZ, + aActualRotationX, + aActualRotationY, + aActualRotationZ); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWLowOrderKinematicPairValue::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_LowOrderKinematicPairValue)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Own fields of PairValue + + theSW.Send (theEnt->AppliesToPair()); + + // Own fields of LowOrderKinematicPairValue + + theSW.Send (theEnt->ActualTranslationX()); + + theSW.Send (theEnt->ActualTranslationY()); + + theSW.Send (theEnt->ActualTranslationZ()); + + theSW.Send (theEnt->ActualRotationX()); + + theSW.Send (theEnt->ActualRotationY()); + + theSW.Send (theEnt->ActualRotationZ()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWLowOrderKinematicPairValue::Share (const Handle(StepKinematics_LowOrderKinematicPairValue)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of PairValue + + iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair()); + + // Own fields of LowOrderKinematicPairValue +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPairValue.hxx new file mode 100644 index 0000000000..b9060d0348 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPairValue.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWLowOrderKinematicPairValue_HeaderFile_ +#define _RWStepKinematics_RWLowOrderKinematicPairValue_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_LowOrderKinematicPairValue)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_LowOrderKinematicPairValue)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_LowOrderKinematicPairValue)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWLowOrderKinematicPairValue_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPairWithRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPairWithRange.cxx new file mode 100644 index 0000000000..f3070a5580 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPairWithRange.cxx @@ -0,0 +1,391 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_LowOrderKinematicPairWithRange)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,24,theArch,"low_order_kinematic_pair_with_range") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of LowOrderKinematicPair + + Standard_Boolean aLowOrderKinematicPair_TX; + theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX); + + Standard_Boolean aLowOrderKinematicPair_TY; + theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY); + + Standard_Boolean aLowOrderKinematicPair_TZ; + theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ); + + Standard_Boolean aLowOrderKinematicPair_RX; + theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX); + + Standard_Boolean aLowOrderKinematicPair_RY; + theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY); + + Standard_Boolean aLowOrderKinematicPair_RZ; + theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ); + + // Own fields of LowOrderKinematicPairWithRange + + Standard_Real aLowerLimitActualRotationX; + Standard_Boolean hasLowerLimitActualRotationX = Standard_True; + if ( theData->IsParamDefined (theNum,13) ) { + theData->ReadReal (theNum, 13, "lower_limit_actual_rotation_x", theArch, aLowerLimitActualRotationX); + } + else { + hasLowerLimitActualRotationX = Standard_False; + aLowerLimitActualRotationX = 0; + } + + Standard_Real aUpperLimitActualRotationX; + Standard_Boolean hasUpperLimitActualRotationX = Standard_True; + if ( theData->IsParamDefined (theNum,14) ) { + theData->ReadReal (theNum, 14, "upper_limit_actual_rotation_x", theArch, aUpperLimitActualRotationX); + } + else { + hasUpperLimitActualRotationX = Standard_False; + aUpperLimitActualRotationX = 0; + } + + Standard_Real aLowerLimitActualRotationY; + Standard_Boolean hasLowerLimitActualRotationY = Standard_True; + if ( theData->IsParamDefined (theNum,15) ) { + theData->ReadReal (theNum, 15, "lower_limit_actual_rotation_y", theArch, aLowerLimitActualRotationY); + } + else { + hasLowerLimitActualRotationY = Standard_False; + aLowerLimitActualRotationY = 0; + } + + Standard_Real aUpperLimitActualRotationY; + Standard_Boolean hasUpperLimitActualRotationY = Standard_True; + if ( theData->IsParamDefined (theNum,16) ) { + theData->ReadReal (theNum, 16, "upper_limit_actual_rotation_y", theArch, aUpperLimitActualRotationY); + } + else { + hasUpperLimitActualRotationY = Standard_False; + aUpperLimitActualRotationY = 0; + } + + Standard_Real aLowerLimitActualRotationZ; + Standard_Boolean hasLowerLimitActualRotationZ = Standard_True; + if ( theData->IsParamDefined (theNum,17) ) { + theData->ReadReal (theNum, 17, "lower_limit_actual_rotation_z", theArch, aLowerLimitActualRotationZ); + } + else { + hasLowerLimitActualRotationZ = Standard_False; + aLowerLimitActualRotationZ = 0; + } + + Standard_Real aUpperLimitActualRotationZ; + Standard_Boolean hasUpperLimitActualRotationZ = Standard_True; + if ( theData->IsParamDefined (theNum,18) ) { + theData->ReadReal (theNum, 18, "upper_limit_actual_rotation_z", theArch, aUpperLimitActualRotationZ); + } + else { + hasUpperLimitActualRotationZ = Standard_False; + aUpperLimitActualRotationZ = 0; + } + + Standard_Real aLowerLimitActualTranslationX; + Standard_Boolean hasLowerLimitActualTranslationX = Standard_True; + if ( theData->IsParamDefined (theNum,19) ) { + theData->ReadReal (theNum, 19, "lower_limit_actual_translation_x", theArch, aLowerLimitActualTranslationX); + } + else { + hasLowerLimitActualTranslationX = Standard_False; + aLowerLimitActualTranslationX = 0; + } + + Standard_Real aUpperLimitActualTranslationX; + Standard_Boolean hasUpperLimitActualTranslationX = Standard_True; + if ( theData->IsParamDefined (theNum,20) ) { + theData->ReadReal (theNum, 20, "upper_limit_actual_translation_x", theArch, aUpperLimitActualTranslationX); + } + else { + hasUpperLimitActualTranslationX = Standard_False; + aUpperLimitActualTranslationX = 0; + } + + Standard_Real aLowerLimitActualTranslationY; + Standard_Boolean hasLowerLimitActualTranslationY = Standard_True; + if ( theData->IsParamDefined (theNum,21) ) { + theData->ReadReal (theNum, 21, "lower_limit_actual_translation_y", theArch, aLowerLimitActualTranslationY); + } + else { + hasLowerLimitActualTranslationY = Standard_False; + aLowerLimitActualTranslationY = 0; + } + + Standard_Real aUpperLimitActualTranslationY; + Standard_Boolean hasUpperLimitActualTranslationY = Standard_True; + if ( theData->IsParamDefined (theNum,22) ) { + theData->ReadReal (theNum, 22, "upper_limit_actual_translation_y", theArch, aUpperLimitActualTranslationY); + } + else { + hasUpperLimitActualTranslationY = Standard_False; + aUpperLimitActualTranslationY = 0; + } + + Standard_Real aLowerLimitActualTranslationZ; + Standard_Boolean hasLowerLimitActualTranslationZ = Standard_True; + if ( theData->IsParamDefined (theNum,23) ) { + theData->ReadReal (theNum, 23, "lower_limit_actual_translation_z", theArch, aLowerLimitActualTranslationZ); + } + else { + hasLowerLimitActualTranslationZ = Standard_False; + aLowerLimitActualTranslationZ = 0; + } + + Standard_Real aUpperLimitActualTranslationZ; + Standard_Boolean hasUpperLimitActualTranslationZ = Standard_True; + if ( theData->IsParamDefined (theNum,24) ) { + theData->ReadReal (theNum, 24, "upper_limit_actual_translation_z", theArch, aUpperLimitActualTranslationZ); + } + else { + hasUpperLimitActualTranslationZ = Standard_False; + aUpperLimitActualTranslationZ = 0; + } + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ, + hasLowerLimitActualRotationX, + aLowerLimitActualRotationX, + hasUpperLimitActualRotationX, + aUpperLimitActualRotationX, + hasLowerLimitActualRotationY, + aLowerLimitActualRotationY, + hasUpperLimitActualRotationY, + aUpperLimitActualRotationY, + hasLowerLimitActualRotationZ, + aLowerLimitActualRotationZ, + hasUpperLimitActualRotationZ, + aUpperLimitActualRotationZ, + hasLowerLimitActualTranslationX, + aLowerLimitActualTranslationX, + hasUpperLimitActualTranslationX, + aUpperLimitActualTranslationX, + hasLowerLimitActualTranslationY, + aLowerLimitActualTranslationY, + hasUpperLimitActualTranslationY, + aUpperLimitActualTranslationY, + hasLowerLimitActualTranslationZ, + aLowerLimitActualTranslationZ, + hasUpperLimitActualTranslationZ, + aUpperLimitActualTranslationZ); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWLowOrderKinematicPairWithRange::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_LowOrderKinematicPairWithRange)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of LowOrderKinematicPair + + theSW.SendBoolean (theEnt->TX()); + + theSW.SendBoolean (theEnt->TY()); + + theSW.SendBoolean (theEnt->TZ()); + + theSW.SendBoolean (theEnt->RX()); + + theSW.SendBoolean (theEnt->RY()); + + theSW.SendBoolean (theEnt->RZ()); + + // Own fields of LowOrderKinematicPairWithRange + + if ( theEnt->HasLowerLimitActualRotationX() ) { + theSW.Send (theEnt->LowerLimitActualRotationX()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitActualRotationX() ) { + theSW.Send (theEnt->UpperLimitActualRotationX()); + } + else theSW.SendUndef(); + + if ( theEnt->HasLowerLimitActualRotationY() ) { + theSW.Send (theEnt->LowerLimitActualRotationY()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitActualRotationY() ) { + theSW.Send (theEnt->UpperLimitActualRotationY()); + } + else theSW.SendUndef(); + + if ( theEnt->HasLowerLimitActualRotationZ() ) { + theSW.Send (theEnt->LowerLimitActualRotationZ()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitActualRotationZ() ) { + theSW.Send (theEnt->UpperLimitActualRotationZ()); + } + else theSW.SendUndef(); + + if ( theEnt->HasLowerLimitActualTranslationX() ) { + theSW.Send (theEnt->LowerLimitActualTranslationX()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitActualTranslationX() ) { + theSW.Send (theEnt->UpperLimitActualTranslationX()); + } + else theSW.SendUndef(); + + if ( theEnt->HasLowerLimitActualTranslationY() ) { + theSW.Send (theEnt->LowerLimitActualTranslationY()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitActualTranslationY() ) { + theSW.Send (theEnt->UpperLimitActualTranslationY()); + } + else theSW.SendUndef(); + + if ( theEnt->HasLowerLimitActualTranslationZ() ) { + theSW.Send (theEnt->LowerLimitActualTranslationZ()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitActualTranslationZ() ) { + theSW.Send (theEnt->UpperLimitActualTranslationZ()); + } + else theSW.SendUndef(); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWLowOrderKinematicPairWithRange::Share (const Handle(StepKinematics_LowOrderKinematicPairWithRange)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of LowOrderKinematicPair + + // Own fields of LowOrderKinematicPairWithRange +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPairWithRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPairWithRange.hxx new file mode 100644 index 0000000000..8b1f3c669d --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPairWithRange.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWLowOrderKinematicPairWithRange_HeaderFile_ +#define _RWStepKinematics_RWLowOrderKinematicPairWithRange_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_LowOrderKinematicPairWithRange)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_LowOrderKinematicPairWithRange)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_LowOrderKinematicPairWithRange)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWLowOrderKinematicPairWithRange_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWMechanismRepresentation.cxx b/src/RWStepKinematics/RWStepKinematics_RWMechanismRepresentation.cxx new file mode 100644 index 0000000000..f15a344521 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWMechanismRepresentation.cxx @@ -0,0 +1,128 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_MechanismRepresentation)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,4,theArch,"mechanism_representation") ) return; + + // Inherited fields of Representation + + Handle(TCollection_HAsciiString) aRepresentation_Name; + theData->ReadString (theNum, 1, "representation.name", theArch, aRepresentation_Name); + + Handle(StepRepr_HArray1OfRepresentationItem) aRepresentation_Items; + Standard_Integer sub2 = 0; + if ( theData->ReadSubList (theNum, 2, "representation.items", theArch, sub2) ) { + Standard_Integer nb0 = theData->NbParams(sub2); + aRepresentation_Items = new StepRepr_HArray1OfRepresentationItem (1, nb0); + Standard_Integer num2 = sub2; + for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) { + Handle(StepRepr_RepresentationItem) anIt0; + theData->ReadEntity (num2, i0, "representation_item", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), anIt0); + aRepresentation_Items->SetValue(i0, anIt0); + } + } + + Handle(StepRepr_RepresentationContext) aRepresentation_ContextOfItems; + theData->ReadEntity (theNum, 3, "representation.context_of_items", theArch, STANDARD_TYPE(StepRepr_RepresentationContext), aRepresentation_ContextOfItems); + + // Own fields of MechanismRepresentation + + StepKinematics_KinematicTopologyRepresentationSelect aRepresentedTopology; + theData->ReadEntity (theNum, 4, "represented_topology", theArch, aRepresentedTopology); + + // Initialize entity + theEnt->Init(aRepresentation_Name, + aRepresentation_Items, + aRepresentation_ContextOfItems, + aRepresentedTopology); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWMechanismRepresentation::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_MechanismRepresentation)& theEnt) const +{ + + // Own fields of Representation + + theSW.Send (theEnt->Name()); + + theSW.OpenSub(); + for (Standard_Integer i1=1; i1 <= theEnt->Items()->Length(); i1++ ) { + Handle(StepRepr_RepresentationItem) Var0 = theEnt->Items()->Value(i1); + theSW.Send (Var0); + } + theSW.CloseSub(); + + theSW.Send (theEnt->ContextOfItems()); + + // Own fields of MechanismRepresentation + + theSW.Send (theEnt->RepresentedTopology().Value()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= + +void RWStepKinematics_RWMechanismRepresentation::Share (const Handle(StepKinematics_MechanismRepresentation)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of Representation + + for (Standard_Integer i1=1; i1 <= theEnt->StepRepr_Representation::Items()->Length(); i1++ ) { + Handle(StepRepr_RepresentationItem) Var0 = theEnt->StepRepr_Representation::Items()->Value(i1); + iter.AddItem (Var0); + } + + iter.AddItem (theEnt->StepRepr_Representation::ContextOfItems()); + + // Own fields of MechanismRepresentation + + iter.AddItem (theEnt->RepresentedTopology().Value()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWMechanismRepresentation.hxx b/src/RWStepKinematics/RWStepKinematics_RWMechanismRepresentation.hxx new file mode 100644 index 0000000000..8032b8f60f --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWMechanismRepresentation.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWMechanismRepresentation_HeaderFile_ +#define _RWStepKinematics_RWMechanismRepresentation_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_MechanismRepresentation)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_MechanismRepresentation)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_MechanismRepresentation)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWMechanismRepresentation_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWMechanismStateRepresentation.cxx b/src/RWStepKinematics/RWStepKinematics_RWMechanismStateRepresentation.cxx new file mode 100644 index 0000000000..26c96aace3 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWMechanismStateRepresentation.cxx @@ -0,0 +1,117 @@ +// Created on: 2020-06-18 +// Created by: PASUKHIN DMITRY +// Copyright (c) 2020 OPEN CASCADE SAS +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//function : RWStepKinematics_RWMechanismStateRepresentation +//purpose : +//======================================================================= +RWStepKinematics_RWMechanismStateRepresentation::RWStepKinematics_RWMechanismStateRepresentation() {} + +//======================================================================= +//function : ReadStep +//purpose : +//======================================================================= +void RWStepKinematics_RWMechanismStateRepresentation::ReadStep + (const Handle(StepData_StepReaderData)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_MechanismStateRepresentation)& theEnt) const +{ + // Number of Parameter Control + if (!theData->CheckNbParams(theNum, 4, theArch, "mechanism_state_representation")) return; + + // Inherited field : name + Handle(TCollection_HAsciiString) aName; + theData->ReadString (theNum, 1, "name" ,theArch, aName); + + // Inherited field : items + Handle(StepRepr_HArray1OfRepresentationItem) aItems; + Handle(StepRepr_RepresentationItem) anEnt; + Standard_Integer nsub; + if (theData->ReadSubList (theNum, 2, "items", theArch, nsub)) { + Standard_Integer nb = theData->NbParams(nsub); + aItems = new StepRepr_HArray1OfRepresentationItem (1, nb); + for (Standard_Integer i = 1; i <= nb; i ++) { + if (theData->ReadEntity (nsub, i, "representation_item", theArch, + STANDARD_TYPE(StepRepr_RepresentationItem), anEnt)) + aItems->SetValue(i, anEnt); + } + } + + // Inherited field : context_of_items + Handle(StepRepr_RepresentationContext) aContextOfItems; + theData->ReadEntity(theNum, 3,"context_of_items", theArch, STANDARD_TYPE(StepRepr_RepresentationContext), aContextOfItems); + + // Inherited field : represented_mechanism + Handle(StepKinematics_MechanismRepresentation) aRepresentedMechanism; + theData->ReadEntity(theNum, 4, "represented_mechanism", theArch, STANDARD_TYPE(StepKinematics_MechanismRepresentation), aRepresentedMechanism); + + // Initialisation of the read entity + theEnt->Init(aName, aItems, aContextOfItems, aRepresentedMechanism); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWMechanismStateRepresentation::WriteStep + (StepData_StepWriter& theSW, + const Handle(StepKinematics_MechanismStateRepresentation)& theEnt) const +{ + // Inherited field : name + theSW.Send(theEnt->Name()); + + // Inherited field : items + theSW.OpenSub(); + for (Standard_Integer i = 1; i <= theEnt->NbItems(); i++) { + theSW.Send(theEnt->ItemsValue(i)); + } + theSW.CloseSub(); + + // Inherited field : context_of_items + theSW.Send(theEnt->ContextOfItems()); + + // Inherited field : represented_mechanism + theSW.Send(theEnt->Mechanism()); + +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWMechanismStateRepresentation::Share(const Handle(StepKinematics_MechanismStateRepresentation)& theEnt, Interface_EntityIterator& iter) const +{ + Standard_Integer nbElem = theEnt->NbItems(); + for (Standard_Integer i = 1; i <= nbElem; i++) { + iter.GetOneItem(theEnt->ItemsValue(i)); + } + iter.GetOneItem(theEnt->ContextOfItems()); + iter.GetOneItem(theEnt->Mechanism()); +} + diff --git a/src/RWStepKinematics/RWStepKinematics_RWMechanismStateRepresentation.hxx b/src/RWStepKinematics/RWStepKinematics_RWMechanismStateRepresentation.hxx new file mode 100644 index 0000000000..5bdde4c7cc --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWMechanismStateRepresentation.hxx @@ -0,0 +1,47 @@ +// Created on: 2020-06-18 +// Created by: PASUKHIN DMITRY +// Copyright (c) 2020 OPEN CASCADE SAS +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWMechanismStateRepresentation_HeaderFile +#define _RWStepKinematics_RWMechanismStateRepresentation_HeaderFile + +#include +#include +#include + +#include +class StepData_StepReaderData; +class Interface_Check; +class StepKinematics_MechanismStateRepresentation; +class StepData_StepWriter; +class Interface_EntityIterator; + + +//! Read & Write Module for MechanismStateRepresentation +class RWStepKinematics_RWMechanismStateRepresentation +{ +public: + + DEFINE_STANDARD_ALLOC + + Standard_EXPORT RWStepKinematics_RWMechanismStateRepresentation(); + + Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_MechanismStateRepresentation)& theEnt) const; + + Standard_EXPORT void WriteStep (StepData_StepWriter& theSW, const Handle(StepKinematics_MechanismStateRepresentation)& theEnt) const; + + Standard_EXPORT void Share (const Handle(StepKinematics_MechanismStateRepresentation)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWMechanismStateRepresentation_HeaderFile diff --git a/src/RWStepKinematics/RWStepKinematics_RWOrientedJoint.cxx b/src/RWStepKinematics/RWStepKinematics_RWOrientedJoint.cxx new file mode 100644 index 0000000000..66c9ce32f9 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWOrientedJoint.cxx @@ -0,0 +1,118 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_OrientedJoint)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,5,theArch,"oriented_joint") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of Edge + + Handle(StepShape_Vertex) aEdge_EdgeStart; + theData->ReadEntity (theNum, 2, "edge.edge_start", theArch, STANDARD_TYPE(StepShape_Vertex), aEdge_EdgeStart); + + Handle(StepShape_Vertex) aEdge_EdgeEnd; + theData->ReadEntity (theNum, 3, "edge.edge_end", theArch, STANDARD_TYPE(StepShape_Vertex), aEdge_EdgeEnd); + + // Inherited fields of OrientedEdge + + Handle(StepShape_Edge) aOrientedEdge_EdgeElement; + theData->ReadEntity (theNum, 4, "oriented_edge.edge_element", theArch, STANDARD_TYPE(StepShape_Edge), aOrientedEdge_EdgeElement); + + Standard_Boolean aOrientedEdge_Orientation; + theData->ReadBoolean (theNum, 5, "oriented_edge.orientation", theArch, aOrientedEdge_Orientation); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aOrientedEdge_EdgeElement, + aOrientedEdge_Orientation); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWOrientedJoint::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_OrientedJoint)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Own fields of Edge + + theSW.Send (theEnt->EdgeStart()); + + theSW.Send (theEnt->EdgeEnd()); + + // Own fields of OrientedEdge + + theSW.Send (theEnt->EdgeElement()); + + theSW.SendBoolean (theEnt->Orientation()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWOrientedJoint::Share (const Handle(StepKinematics_OrientedJoint)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of Edge + + iter.AddItem (theEnt->StepShape_Edge::EdgeStart()); + + iter.AddItem (theEnt->StepShape_Edge::EdgeEnd()); + + // Inherited fields of OrientedEdge + + iter.AddItem (theEnt->StepShape_OrientedEdge::EdgeElement()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWOrientedJoint.hxx b/src/RWStepKinematics/RWStepKinematics_RWOrientedJoint.hxx new file mode 100644 index 0000000000..47dd3f9f2e --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWOrientedJoint.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWOrientedJoint_HeaderFile_ +#define _RWStepKinematics_RWOrientedJoint_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_OrientedJoint)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_OrientedJoint)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_OrientedJoint)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWOrientedJoint_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPairRepresentationRelationship.cxx b/src/RWStepKinematics/RWStepKinematics_RWPairRepresentationRelationship.cxx new file mode 100644 index 0000000000..5dfd3e531f --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPairRepresentationRelationship.cxx @@ -0,0 +1,138 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//function : RWStepKinematics_RWPairRepresentationRelationship +//purpose : +//======================================================================= +RWStepKinematics_RWPairRepresentationRelationship::RWStepKinematics_RWPairRepresentationRelationship() {} + + +//======================================================================= +//function : ReadStep +//purpose : +//======================================================================= +void RWStepKinematics_RWPairRepresentationRelationship::ReadStep (const Handle(StepData_StepReaderData)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_PairRepresentationRelationship)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,6,theArch,"pair_representation_relationship") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of RepresentationRelationship + + Handle(TCollection_HAsciiString) aRepresentationRelationship_Name; + theData->ReadString (theNum, 2, "representation_relationship.name", theArch, aRepresentationRelationship_Name); + + Handle(TCollection_HAsciiString) aRepresentationRelationship_Description; + Standard_Boolean hasRepresentationRelationship_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "representation_relationship.description", theArch, aRepresentationRelationship_Description); + } + else { + hasRepresentationRelationship_Description = Standard_False; + aRepresentationRelationship_Description.Nullify(); + } + + StepRepr_RepresentationOrRepresentationReference aRepresentationRelationship_Rep1; + theData->ReadEntity (theNum, 4, "representation_relationship.rep1", theArch, aRepresentationRelationship_Rep1); + + StepRepr_RepresentationOrRepresentationReference aRepresentationRelationship_Rep2; + theData->ReadEntity (theNum, 5, "representation_relationship.rep2", theArch, aRepresentationRelationship_Rep2); + + // Inherited fields of RepresentationRelationshipWithTransformation + + StepRepr_Transformation aRepresentationRelationshipWithTransformation_TransformationOperator; + theData->ReadEntity (theNum, 6, "representation_relationship_with_transformation.transformation_operator", theArch, aRepresentationRelationshipWithTransformation_TransformationOperator); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aRepresentationRelationship_Name, + hasRepresentationRelationship_Description, + aRepresentationRelationship_Description, + aRepresentationRelationship_Rep1, + aRepresentationRelationship_Rep2, + aRepresentationRelationshipWithTransformation_TransformationOperator); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWPairRepresentationRelationship::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_PairRepresentationRelationship)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Own fields of RepresentationRelationship + + theSW.Send (theEnt->Name()); + + + if (theEnt->RepresentationRelationshipWithTransformation()->HasDescription()) + theSW.Send (theEnt->RepresentationRelationshipWithTransformation()->Description()); + else theSW.SendUndef(); + + theSW.Send (theEnt->RepresentationRelationshipWithTransformation()->Rep1()); + + theSW.Send (theEnt->RepresentationRelationshipWithTransformation()->Rep2()); + + // Inherited fields of RepresentationRelationshipWithTransformation + + theSW.Send (theEnt->RepresentationRelationshipWithTransformation()->TransformationOperator().Value()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWPairRepresentationRelationship::Share (const Handle(StepKinematics_PairRepresentationRelationship)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of RepresentationRelationship + + iter.AddItem (theEnt->RepresentationRelationshipWithTransformation()->Rep1()); + + iter.AddItem (theEnt->RepresentationRelationshipWithTransformation()->Rep2()); + + // Inherited fields of RepresentationRelationshipWithTransformation + + iter.AddItem (theEnt->RepresentationRelationshipWithTransformation()->TransformationOperator().Value()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPairRepresentationRelationship.hxx b/src/RWStepKinematics/RWStepKinematics_RWPairRepresentationRelationship.hxx new file mode 100644 index 0000000000..23fa5e698f --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPairRepresentationRelationship.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWPairRepresentationRelationship_HeaderFile_ +#define _RWStepKinematics_RWPairRepresentationRelationship_HeaderFile_ + +#include +#include +#include + +class StepData_StepReaderData; +class Interface_Check; +class StepData_StepWriter; +class Interface_EntityIterator; +class StepKinematics_PairRepresentationRelationship; + +//! Read & Write tool for PairRepresentationRelationship +class RWStepKinematics_RWPairRepresentationRelationship +{ +public: + + DEFINE_STANDARD_ALLOC + + Standard_EXPORT RWStepKinematics_RWPairRepresentationRelationship(); + + Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PairRepresentationRelationship)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PairRepresentationRelationship)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_PairRepresentationRelationship)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWPairRepresentationRelationship_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPlanarCurvePair.cxx b/src/RWStepKinematics/RWStepKinematics_RWPlanarCurvePair.cxx new file mode 100644 index 0000000000..58564bcae7 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPlanarCurvePair.cxx @@ -0,0 +1,167 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_PlanarCurvePair)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,9,theArch,"planar_curve_pair") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Own fields of PlanarCurvePair + + Handle(StepGeom_Curve) aCurve1; + theData->ReadEntity (theNum, 7, "curve1", theArch, STANDARD_TYPE(StepGeom_Curve), aCurve1); + + Handle(StepGeom_Curve) aCurve2; + theData->ReadEntity (theNum, 8, "curve2", theArch, STANDARD_TYPE(StepGeom_Curve), aCurve2); + + Standard_Boolean aOrientation; + theData->ReadBoolean (theNum, 9, "orientation", theArch, aOrientation); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aCurve1, + aCurve2, + aOrientation); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWPlanarCurvePair::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_PlanarCurvePair)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of PlanarCurvePair + + theSW.Send (theEnt->Curve1()); + + theSW.Send (theEnt->Curve2()); + + theSW.SendBoolean (theEnt->Orientation()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWPlanarCurvePair::Share (const Handle(StepKinematics_PlanarCurvePair)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Own fields of PlanarCurvePair + + iter.AddItem (theEnt->Curve1()); + + iter.AddItem (theEnt->Curve2()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPlanarCurvePair.hxx b/src/RWStepKinematics/RWStepKinematics_RWPlanarCurvePair.hxx new file mode 100644 index 0000000000..577b943242 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPlanarCurvePair.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWPlanarCurvePair_HeaderFile_ +#define _RWStepKinematics_RWPlanarCurvePair_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PlanarCurvePair)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PlanarCurvePair)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_PlanarCurvePair)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWPlanarCurvePair_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPlanarCurvePairRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWPlanarCurvePairRange.cxx new file mode 100644 index 0000000000..5b75c30eb1 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPlanarCurvePairRange.cxx @@ -0,0 +1,190 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_PlanarCurvePairRange)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,11,theArch,"planar_curve_pair_range") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of PlanarCurvePair + + Handle(StepGeom_Curve) aPlanarCurvePair_Curve1; + theData->ReadEntity (theNum, 7, "planar_curve_pair.curve1", theArch, STANDARD_TYPE(StepGeom_Curve), aPlanarCurvePair_Curve1); + + Handle(StepGeom_Curve) aPlanarCurvePair_Curve2; + theData->ReadEntity (theNum, 8, "planar_curve_pair.curve2", theArch, STANDARD_TYPE(StepGeom_Curve), aPlanarCurvePair_Curve2); + + Standard_Boolean aPlanarCurvePair_Orientation; + theData->ReadBoolean (theNum, 9, "planar_curve_pair.orientation", theArch, aPlanarCurvePair_Orientation); + + // Own fields of PlanarCurvePairRange + + Handle(StepGeom_TrimmedCurve) aRangeOnCurve1; + theData->ReadEntity (theNum, 10, "range_on_curve1", theArch, STANDARD_TYPE(StepGeom_TrimmedCurve), aRangeOnCurve1); + + Handle(StepGeom_TrimmedCurve) aRangeOnCurve2; + theData->ReadEntity (theNum, 11, "range_on_curve2", theArch, STANDARD_TYPE(StepGeom_TrimmedCurve), aRangeOnCurve2); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aPlanarCurvePair_Curve1, + aPlanarCurvePair_Curve2, + aPlanarCurvePair_Orientation, + aRangeOnCurve1, + aRangeOnCurve2); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWPlanarCurvePairRange::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_PlanarCurvePairRange)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of PlanarCurvePair + + theSW.Send (theEnt->Curve1()); + + theSW.Send (theEnt->Curve2()); + + theSW.SendBoolean (theEnt->Orientation()); + + // Own fields of PlanarCurvePairRange + + theSW.Send (theEnt->RangeOnCurve1()); + + theSW.Send (theEnt->RangeOnCurve2()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWPlanarCurvePairRange::Share (const Handle(StepKinematics_PlanarCurvePairRange)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of PlanarCurvePair + + iter.AddItem (theEnt->StepKinematics_PlanarCurvePair::Curve1()); + + iter.AddItem (theEnt->StepKinematics_PlanarCurvePair::Curve2()); + + // Own fields of PlanarCurvePairRange + + iter.AddItem (theEnt->RangeOnCurve1()); + + iter.AddItem (theEnt->RangeOnCurve2()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPlanarCurvePairRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWPlanarCurvePairRange.hxx new file mode 100644 index 0000000000..8da86eeaa4 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPlanarCurvePairRange.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWPlanarCurvePairRange_HeaderFile_ +#define _RWStepKinematics_RWPlanarCurvePairRange_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PlanarCurvePairRange)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PlanarCurvePairRange)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_PlanarCurvePairRange)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWPlanarCurvePairRange_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPlanarPair.cxx b/src/RWStepKinematics/RWStepKinematics_RWPlanarPair.cxx new file mode 100644 index 0000000000..775498f47d --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPlanarPair.cxx @@ -0,0 +1,180 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_PlanarPair)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,12,theArch,"planar_pair") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of LowOrderKinematicPair + + Standard_Boolean aLowOrderKinematicPair_TX; + theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX); + + Standard_Boolean aLowOrderKinematicPair_TY; + theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY); + + Standard_Boolean aLowOrderKinematicPair_TZ; + theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ); + + Standard_Boolean aLowOrderKinematicPair_RX; + theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX); + + Standard_Boolean aLowOrderKinematicPair_RY; + theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY); + + Standard_Boolean aLowOrderKinematicPair_RZ; + theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWPlanarPair::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_PlanarPair)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of LowOrderKinematicPair + + theSW.SendBoolean (theEnt->TX()); + + theSW.SendBoolean (theEnt->TY()); + + theSW.SendBoolean (theEnt->TZ()); + + theSW.SendBoolean (theEnt->RX()); + + theSW.SendBoolean (theEnt->RY()); + + theSW.SendBoolean (theEnt->RZ()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWPlanarPair::Share (const Handle(StepKinematics_PlanarPair)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of LowOrderKinematicPair +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPlanarPair.hxx b/src/RWStepKinematics/RWStepKinematics_RWPlanarPair.hxx new file mode 100644 index 0000000000..8ba23e684f --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPlanarPair.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWPlanarPair_HeaderFile_ +#define _RWStepKinematics_RWPlanarPair_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PlanarPair)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PlanarPair)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_PlanarPair)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWPlanarPair_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPlanarPairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWPlanarPairValue.cxx new file mode 100644 index 0000000000..f93b976eb3 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPlanarPairValue.cxx @@ -0,0 +1,115 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_PlanarPairValue)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,5,theArch,"planar_pair_value") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of PairValue + + Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair; + theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair); + + // Own fields of PlanarPairValue + + Standard_Real aActualRotation; + theData->ReadReal (theNum, 3, "actual_rotation", theArch, aActualRotation); + + Standard_Real aActualTranslationX; + theData->ReadReal (theNum, 4, "actual_translation_x", theArch, aActualTranslationX); + + Standard_Real aActualTranslationY; + theData->ReadReal (theNum, 5, "actual_translation_y", theArch, aActualTranslationY); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aPairValue_AppliesToPair, + aActualRotation, + aActualTranslationX, + aActualTranslationY); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWPlanarPairValue::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_PlanarPairValue)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Own fields of PairValue + + theSW.Send (theEnt->AppliesToPair()); + + // Own fields of PlanarPairValue + + theSW.Send (theEnt->ActualRotation()); + + theSW.Send (theEnt->ActualTranslationX()); + + theSW.Send (theEnt->ActualTranslationY()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWPlanarPairValue::Share (const Handle(StepKinematics_PlanarPairValue)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of PairValue + + iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair()); + + // Own fields of PlanarPairValue +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPlanarPairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWPlanarPairValue.hxx new file mode 100644 index 0000000000..5382856a06 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPlanarPairValue.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWPlanarPairValue_HeaderFile_ +#define _RWStepKinematics_RWPlanarPairValue_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PlanarPairValue)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PlanarPairValue)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_PlanarPairValue)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWPlanarPairValue_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPlanarPairWithRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWPlanarPairWithRange.cxx new file mode 100644 index 0000000000..4426dadb46 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPlanarPairWithRange.cxx @@ -0,0 +1,289 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_PlanarPairWithRange)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,18,theArch,"planar_pair_with_range") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of LowOrderKinematicPair + + Standard_Boolean aLowOrderKinematicPair_TX; + theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX); + + Standard_Boolean aLowOrderKinematicPair_TY; + theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY); + + Standard_Boolean aLowOrderKinematicPair_TZ; + theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ); + + Standard_Boolean aLowOrderKinematicPair_RX; + theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX); + + Standard_Boolean aLowOrderKinematicPair_RY; + theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY); + + Standard_Boolean aLowOrderKinematicPair_RZ; + theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ); + + // Own fields of PlanarPairWithRange + + Standard_Real aLowerLimitActualRotation; + Standard_Boolean hasLowerLimitActualRotation = Standard_True; + if ( theData->IsParamDefined (theNum,13) ) { + theData->ReadReal (theNum, 13, "lower_limit_actual_rotation", theArch, aLowerLimitActualRotation); + } + else { + hasLowerLimitActualRotation = Standard_False; + aLowerLimitActualRotation = 0; + } + + Standard_Real aUpperLimitActualRotation; + Standard_Boolean hasUpperLimitActualRotation = Standard_True; + if ( theData->IsParamDefined (theNum,14) ) { + theData->ReadReal (theNum, 14, "upper_limit_actual_rotation", theArch, aUpperLimitActualRotation); + } + else { + hasUpperLimitActualRotation = Standard_False; + aUpperLimitActualRotation = 0; + } + + Standard_Real aLowerLimitActualTranslationX; + Standard_Boolean hasLowerLimitActualTranslationX = Standard_True; + if ( theData->IsParamDefined (theNum,15) ) { + theData->ReadReal (theNum, 15, "lower_limit_actual_translation_x", theArch, aLowerLimitActualTranslationX); + } + else { + hasLowerLimitActualTranslationX = Standard_False; + aLowerLimitActualTranslationX = 0; + } + + Standard_Real aUpperLimitActualTranslationX; + Standard_Boolean hasUpperLimitActualTranslationX = Standard_True; + if ( theData->IsParamDefined (theNum,16) ) { + theData->ReadReal (theNum, 16, "upper_limit_actual_translation_x", theArch, aUpperLimitActualTranslationX); + } + else { + hasUpperLimitActualTranslationX = Standard_False; + aUpperLimitActualTranslationX = 0; + } + + Standard_Real aLowerLimitActualTranslationY; + Standard_Boolean hasLowerLimitActualTranslationY = Standard_True; + if ( theData->IsParamDefined (theNum,17) ) { + theData->ReadReal (theNum, 17, "lower_limit_actual_translation_y", theArch, aLowerLimitActualTranslationY); + } + else { + hasLowerLimitActualTranslationY = Standard_False; + aLowerLimitActualTranslationY = 0; + } + + Standard_Real aUpperLimitActualTranslationY; + Standard_Boolean hasUpperLimitActualTranslationY = Standard_True; + if ( theData->IsParamDefined (theNum,18) ) { + theData->ReadReal (theNum, 18, "upper_limit_actual_translation_y", theArch, aUpperLimitActualTranslationY); + } + else { + hasUpperLimitActualTranslationY = Standard_False; + aUpperLimitActualTranslationY = 0; + } + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ, + hasLowerLimitActualRotation, + aLowerLimitActualRotation, + hasUpperLimitActualRotation, + aUpperLimitActualRotation, + hasLowerLimitActualTranslationX, + aLowerLimitActualTranslationX, + hasUpperLimitActualTranslationX, + aUpperLimitActualTranslationX, + hasLowerLimitActualTranslationY, + aLowerLimitActualTranslationY, + hasUpperLimitActualTranslationY, + aUpperLimitActualTranslationY); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWPlanarPairWithRange::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_PlanarPairWithRange)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of LowOrderKinematicPair + + theSW.SendBoolean (theEnt->TX()); + + theSW.SendBoolean (theEnt->TY()); + + theSW.SendBoolean (theEnt->TZ()); + + theSW.SendBoolean (theEnt->RX()); + + theSW.SendBoolean (theEnt->RY()); + + theSW.SendBoolean (theEnt->RZ()); + + // Own fields of PlanarPairWithRange + + if ( theEnt->HasLowerLimitActualRotation() ) { + theSW.Send (theEnt->LowerLimitActualRotation()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitActualRotation() ) { + theSW.Send (theEnt->UpperLimitActualRotation()); + } + else theSW.SendUndef(); + + if ( theEnt->HasLowerLimitActualTranslationX() ) { + theSW.Send (theEnt->LowerLimitActualTranslationX()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitActualTranslationX() ) { + theSW.Send (theEnt->UpperLimitActualTranslationX()); + } + else theSW.SendUndef(); + + if ( theEnt->HasLowerLimitActualTranslationY() ) { + theSW.Send (theEnt->LowerLimitActualTranslationY()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitActualTranslationY() ) { + theSW.Send (theEnt->UpperLimitActualTranslationY()); + } + else theSW.SendUndef(); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWPlanarPairWithRange::Share (const Handle(StepKinematics_PlanarPairWithRange)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of LowOrderKinematicPair + + // Own fields of PlanarPairWithRange +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPlanarPairWithRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWPlanarPairWithRange.hxx new file mode 100644 index 0000000000..f1a8229a8a --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPlanarPairWithRange.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWPlanarPairWithRange_HeaderFile_ +#define _RWStepKinematics_RWPlanarPairWithRange_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PlanarPairWithRange)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PlanarPairWithRange)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_PlanarPairWithRange)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWPlanarPairWithRange_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePair.cxx b/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePair.cxx new file mode 100644 index 0000000000..72fa34aa09 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePair.cxx @@ -0,0 +1,159 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_PointOnPlanarCurvePair)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,8,theArch,"point_on_planar_curve_pair") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Own fields of PointOnPlanarCurvePair + + Handle(StepGeom_Curve) aPairCurve; + theData->ReadEntity (theNum, 7, "pair_curve", theArch, STANDARD_TYPE(StepGeom_Curve), aPairCurve); + + Standard_Boolean aOrientation; + theData->ReadBoolean (theNum, 8, "orientation", theArch, aOrientation); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aPairCurve, + aOrientation); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWPointOnPlanarCurvePair::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_PointOnPlanarCurvePair)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of PointOnPlanarCurvePair + + theSW.Send (theEnt->PairCurve()); + + theSW.SendBoolean (theEnt->Orientation()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWPointOnPlanarCurvePair::Share (const Handle(StepKinematics_PointOnPlanarCurvePair)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Own fields of PointOnPlanarCurvePair + + iter.AddItem (theEnt->PairCurve()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePair.hxx b/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePair.hxx new file mode 100644 index 0000000000..54d5fd1545 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePair.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWPointOnPlanarCurvePair_HeaderFile_ +#define _RWStepKinematics_RWPointOnPlanarCurvePair_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PointOnPlanarCurvePair)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PointOnPlanarCurvePair)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_PointOnPlanarCurvePair)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWPointOnPlanarCurvePair_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePairValue.cxx new file mode 100644 index 0000000000..c05ef8f6e6 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePairValue.cxx @@ -0,0 +1,142 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#include +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_PointOnPlanarCurvePairValue)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,4,theArch,"point_on_planar_curve_pair_value") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of PairValue + + Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair; + theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair); + + // Own fields of PointOnPlanarCurvePairValue + + Handle(StepGeom_PointOnCurve) aActualPointOnCurve; + theData->ReadEntity (theNum, 3, "actual_point_on_curve", theArch, STANDARD_TYPE(StepGeom_PointOnCurve), aActualPointOnCurve); + + StepKinematics_SpatialRotation aInputOrientation; + if (theData->SubListNumber(theNum, 4, Standard_True)) + { + Handle(TColStd_HArray1OfReal) aItems; + Standard_Integer nsub = 0; + if (theData->ReadSubList(theNum, 4, "items", theArch, nsub)) { + Standard_Integer nb = theData->NbParams(nsub); + aItems = new TColStd_HArray1OfReal(1, nb); + Standard_Integer num2 = nsub; + for (Standard_Integer i0 = 1; i0 <= nb; i0++) { + Standard_Real anIt0; + theData->ReadReal(num2, i0, "real", theArch, anIt0); + aItems->SetValue(i0, anIt0); + } + } + aInputOrientation.SetValue(aItems); + } + else + theData->ReadEntity(theNum, 4, "input_orientation", theArch, aInputOrientation); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aPairValue_AppliesToPair, + aActualPointOnCurve, + aInputOrientation); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWPointOnPlanarCurvePairValue::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_PointOnPlanarCurvePairValue)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Own fields of PairValue + + theSW.Send (theEnt->AppliesToPair()); + + // Own fields of PointOnPlanarCurvePairValue + + theSW.Send (theEnt->ActualPointOnCurve()); + + if (!theEnt->InputOrientation().YprRotation().IsNull()) + { + // Inherited field : YPR + theSW.OpenSub(); + for (Standard_Integer i = 1; i <= theEnt->InputOrientation().YprRotation()->Length(); i++) { + theSW.Send(theEnt->InputOrientation().YprRotation()->Value(i)); + } + theSW.CloseSub(); + } + else + theSW.Send(theEnt->InputOrientation().Value()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWPointOnPlanarCurvePairValue::Share (const Handle(StepKinematics_PointOnPlanarCurvePairValue)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of PairValue + + iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair()); + + // Own fields of PointOnPlanarCurvePairValue + + iter.AddItem (theEnt->ActualPointOnCurve()); + + if (!theEnt->InputOrientation().RotationAboutDirection().IsNull()) + iter.AddItem(theEnt->InputOrientation().Value()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePairValue.hxx new file mode 100644 index 0000000000..29e605eb87 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePairValue.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWPointOnPlanarCurvePairValue_HeaderFile_ +#define _RWStepKinematics_RWPointOnPlanarCurvePairValue_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PointOnPlanarCurvePairValue)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PointOnPlanarCurvePairValue)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_PointOnPlanarCurvePairValue)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWPointOnPlanarCurvePairValue_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePairWithRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePairWithRange.cxx new file mode 100644 index 0000000000..1760cea88a --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePairWithRange.cxx @@ -0,0 +1,277 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_PointOnPlanarCurvePairWithRange)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,15,theArch,"point_on_planar_curve_pair_with_range") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of PointOnPlanarCurvePair + + Handle(StepGeom_Curve) aPointOnPlanarCurvePair_PairCurve; + theData->ReadEntity (theNum, 7, "point_on_planar_curve_pair.pair_curve", theArch, STANDARD_TYPE(StepGeom_Curve), aPointOnPlanarCurvePair_PairCurve); + + Standard_Boolean aPointOnPlanarCurvePair_Orientation; + theData->ReadBoolean (theNum, 8, "point_on_planar_curve_pair.orientation", theArch, aPointOnPlanarCurvePair_Orientation); + + // Own fields of PointOnPlanarCurvePairWithRange + + Handle(StepGeom_TrimmedCurve) aRangeOnPairCurve; + theData->ReadEntity (theNum, 9, "range_on_pair_curve", theArch, STANDARD_TYPE(StepGeom_TrimmedCurve), aRangeOnPairCurve); + + Standard_Real aLowerLimitYaw; + Standard_Boolean hasLowerLimitYaw = Standard_True; + if ( theData->IsParamDefined (theNum,10) ) { + theData->ReadReal (theNum, 10, "lower_limit_yaw", theArch, aLowerLimitYaw); + } + else { + hasLowerLimitYaw = Standard_False; + aLowerLimitYaw = 0; + } + + Standard_Real aUpperLimitYaw; + Standard_Boolean hasUpperLimitYaw = Standard_True; + if ( theData->IsParamDefined (theNum,11) ) { + theData->ReadReal (theNum, 11, "upper_limit_yaw", theArch, aUpperLimitYaw); + } + else { + hasUpperLimitYaw = Standard_False; + aUpperLimitYaw = 0; + } + + Standard_Real aLowerLimitPitch; + Standard_Boolean hasLowerLimitPitch = Standard_True; + if ( theData->IsParamDefined (theNum,12) ) { + theData->ReadReal (theNum, 12, "lower_limit_pitch", theArch, aLowerLimitPitch); + } + else { + hasLowerLimitPitch = Standard_False; + aLowerLimitPitch = 0; + } + + Standard_Real aUpperLimitPitch; + Standard_Boolean hasUpperLimitPitch = Standard_True; + if ( theData->IsParamDefined (theNum,13) ) { + theData->ReadReal (theNum, 13, "upper_limit_pitch", theArch, aUpperLimitPitch); + } + else { + hasUpperLimitPitch = Standard_False; + aUpperLimitPitch = 0; + } + + Standard_Real aLowerLimitRoll; + Standard_Boolean hasLowerLimitRoll = Standard_True; + if ( theData->IsParamDefined (theNum,14) ) { + theData->ReadReal (theNum, 14, "lower_limit_roll", theArch, aLowerLimitRoll); + } + else { + hasLowerLimitRoll = Standard_False; + aLowerLimitRoll = 0; + } + + Standard_Real aUpperLimitRoll; + Standard_Boolean hasUpperLimitRoll = Standard_True; + if ( theData->IsParamDefined (theNum,15) ) { + theData->ReadReal (theNum, 15, "upper_limit_roll", theArch, aUpperLimitRoll); + } + else { + hasUpperLimitRoll = Standard_False; + aUpperLimitRoll = 0; + } + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aPointOnPlanarCurvePair_PairCurve, + aPointOnPlanarCurvePair_Orientation, + aRangeOnPairCurve, + hasLowerLimitYaw, + aLowerLimitYaw, + hasUpperLimitYaw, + aUpperLimitYaw, + hasLowerLimitPitch, + aLowerLimitPitch, + hasUpperLimitPitch, + aUpperLimitPitch, + hasLowerLimitRoll, + aLowerLimitRoll, + hasUpperLimitRoll, + aUpperLimitRoll); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWPointOnPlanarCurvePairWithRange::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_PointOnPlanarCurvePairWithRange)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of PointOnPlanarCurvePair + + theSW.Send (theEnt->PairCurve()); + + theSW.SendBoolean (theEnt->Orientation()); + + // Own fields of PointOnPlanarCurvePairWithRange + + theSW.Send (theEnt->RangeOnPairCurve()); + + if ( theEnt->HasLowerLimitYaw() ) { + theSW.Send (theEnt->LowerLimitYaw()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitYaw() ) { + theSW.Send (theEnt->UpperLimitYaw()); + } + else theSW.SendUndef(); + + if ( theEnt->HasLowerLimitPitch() ) { + theSW.Send (theEnt->LowerLimitPitch()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitPitch() ) { + theSW.Send (theEnt->UpperLimitPitch()); + } + else theSW.SendUndef(); + + if ( theEnt->HasLowerLimitRoll() ) { + theSW.Send (theEnt->LowerLimitRoll()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitRoll() ) { + theSW.Send (theEnt->UpperLimitRoll()); + } + else theSW.SendUndef(); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWPointOnPlanarCurvePairWithRange::Share (const Handle(StepKinematics_PointOnPlanarCurvePairWithRange)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of PointOnPlanarCurvePair + + iter.AddItem (theEnt->StepKinematics_PointOnPlanarCurvePair::PairCurve()); + + // Own fields of PointOnPlanarCurvePairWithRange + + iter.AddItem (theEnt->RangeOnPairCurve()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePairWithRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePairWithRange.hxx new file mode 100644 index 0000000000..b4c93d4707 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePairWithRange.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWPointOnPlanarCurvePairWithRange_HeaderFile_ +#define _RWStepKinematics_RWPointOnPlanarCurvePairWithRange_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PointOnPlanarCurvePairWithRange)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PointOnPlanarCurvePairWithRange)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_PointOnPlanarCurvePairWithRange)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWPointOnPlanarCurvePairWithRange_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePair.cxx b/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePair.cxx new file mode 100644 index 0000000000..3c476808e7 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePair.cxx @@ -0,0 +1,152 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_PointOnSurfacePair)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,7,theArch,"point_on_surface_pair") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Own fields of PointOnSurfacePair + + Handle(StepGeom_Surface) aPairSurface; + theData->ReadEntity (theNum, 7, "pair_surface", theArch, STANDARD_TYPE(StepGeom_Surface), aPairSurface); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aPairSurface); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWPointOnSurfacePair::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_PointOnSurfacePair)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of PointOnSurfacePair + + theSW.Send (theEnt->PairSurface()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWPointOnSurfacePair::Share (const Handle(StepKinematics_PointOnSurfacePair)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Own fields of PointOnSurfacePair + + iter.AddItem (theEnt->PairSurface()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePair.hxx b/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePair.hxx new file mode 100644 index 0000000000..d990b26468 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePair.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWPointOnSurfacePair_HeaderFile_ +#define _RWStepKinematics_RWPointOnSurfacePair_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PointOnSurfacePair)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PointOnSurfacePair)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_PointOnSurfacePair)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWPointOnSurfacePair_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePairValue.cxx new file mode 100644 index 0000000000..94ae94355c --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePairValue.cxx @@ -0,0 +1,142 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#include +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_PointOnSurfacePairValue)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,4,theArch,"point_on_surface_pair_value") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of PairValue + + Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair; + theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair); + + // Own fields of PointOnSurfacePairValue + + Handle(StepGeom_PointOnSurface) aActualPointOnSurface; + theData->ReadEntity (theNum, 3, "actual_point_on_surface", theArch, STANDARD_TYPE(StepGeom_PointOnSurface), aActualPointOnSurface); + + StepKinematics_SpatialRotation aInputOrientation; + if (theData->SubListNumber(theNum, 4, Standard_True)) + { + Handle(TColStd_HArray1OfReal) aItems; + Standard_Integer nsub = 0; + if (theData->ReadSubList(theNum, 4, "items", theArch, nsub)) { + Standard_Integer nb = theData->NbParams(nsub); + aItems = new TColStd_HArray1OfReal(1, nb); + Standard_Integer num2 = nsub; + for (Standard_Integer i0 = 1; i0 <= nb; i0++) { + Standard_Real anIt0; + theData->ReadReal(num2, i0, "real", theArch, anIt0); + aItems->SetValue(i0, anIt0); + } + } + aInputOrientation.SetValue(aItems); + } + else + theData->ReadEntity(theNum, 4, "input_orientation", theArch, aInputOrientation); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aPairValue_AppliesToPair, + aActualPointOnSurface, + aInputOrientation); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWPointOnSurfacePairValue::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_PointOnSurfacePairValue)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Own fields of PairValue + + theSW.Send (theEnt->AppliesToPair()); + + // Own fields of PointOnSurfacePairValue + + theSW.Send (theEnt->ActualPointOnSurface()); + + if (!theEnt->InputOrientation().YprRotation().IsNull()) + { + // Inherited field : YPR + theSW.OpenSub(); + for (Standard_Integer i = 1; i <= theEnt->InputOrientation().YprRotation()->Length(); i++) { + theSW.Send(theEnt->InputOrientation().YprRotation()->Value(i)); + } + theSW.CloseSub(); + } + else + theSW.Send(theEnt->InputOrientation().Value()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWPointOnSurfacePairValue::Share (const Handle(StepKinematics_PointOnSurfacePairValue)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of PairValue + + iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair()); + + // Own fields of PointOnSurfacePairValue + + iter.AddItem (theEnt->ActualPointOnSurface()); + + if (!theEnt->InputOrientation().RotationAboutDirection().IsNull()) + iter.AddItem(theEnt->InputOrientation().Value()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePairValue.hxx new file mode 100644 index 0000000000..b8341294c9 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePairValue.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWPointOnSurfacePairValue_HeaderFile_ +#define _RWStepKinematics_RWPointOnSurfacePairValue_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PointOnSurfacePairValue)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PointOnSurfacePairValue)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_PointOnSurfacePairValue)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWPointOnSurfacePairValue_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePairWithRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePairWithRange.cxx new file mode 100644 index 0000000000..91014584d9 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePairWithRange.cxx @@ -0,0 +1,270 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_PointOnSurfacePairWithRange)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,14,theArch,"point_on_surface_pair_with_range") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of PointOnSurfacePair + + Handle(StepGeom_Surface) aPointOnSurfacePair_PairSurface; + theData->ReadEntity (theNum, 7, "point_on_surface_pair.pair_surface", theArch, STANDARD_TYPE(StepGeom_Surface), aPointOnSurfacePair_PairSurface); + + // Own fields of PointOnSurfacePairWithRange + + Handle(StepGeom_RectangularTrimmedSurface) aRangeOnPairSurface; + theData->ReadEntity (theNum, 8, "range_on_pair_surface", theArch, STANDARD_TYPE(StepGeom_RectangularTrimmedSurface), aRangeOnPairSurface); + + Standard_Real aLowerLimitYaw; + Standard_Boolean hasLowerLimitYaw = Standard_True; + if ( theData->IsParamDefined (theNum,9) ) { + theData->ReadReal (theNum, 9, "lower_limit_yaw", theArch, aLowerLimitYaw); + } + else { + hasLowerLimitYaw = Standard_False; + aLowerLimitYaw = 0; + } + + Standard_Real aUpperLimitYaw; + Standard_Boolean hasUpperLimitYaw = Standard_True; + if ( theData->IsParamDefined (theNum,10) ) { + theData->ReadReal (theNum, 10, "upper_limit_yaw", theArch, aUpperLimitYaw); + } + else { + hasUpperLimitYaw = Standard_False; + aUpperLimitYaw = 0; + } + + Standard_Real aLowerLimitPitch; + Standard_Boolean hasLowerLimitPitch = Standard_True; + if ( theData->IsParamDefined (theNum,11) ) { + theData->ReadReal (theNum, 11, "lower_limit_pitch", theArch, aLowerLimitPitch); + } + else { + hasLowerLimitPitch = Standard_False; + aLowerLimitPitch = 0; + } + + Standard_Real aUpperLimitPitch; + Standard_Boolean hasUpperLimitPitch = Standard_True; + if ( theData->IsParamDefined (theNum,12) ) { + theData->ReadReal (theNum, 12, "upper_limit_pitch", theArch, aUpperLimitPitch); + } + else { + hasUpperLimitPitch = Standard_False; + aUpperLimitPitch = 0; + } + + Standard_Real aLowerLimitRoll; + Standard_Boolean hasLowerLimitRoll = Standard_True; + if ( theData->IsParamDefined (theNum,13) ) { + theData->ReadReal (theNum, 13, "lower_limit_roll", theArch, aLowerLimitRoll); + } + else { + hasLowerLimitRoll = Standard_False; + aLowerLimitRoll = 0; + } + + Standard_Real aUpperLimitRoll; + Standard_Boolean hasUpperLimitRoll = Standard_True; + if ( theData->IsParamDefined (theNum,14) ) { + theData->ReadReal (theNum, 14, "upper_limit_roll", theArch, aUpperLimitRoll); + } + else { + hasUpperLimitRoll = Standard_False; + aUpperLimitRoll = 0; + } + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aPointOnSurfacePair_PairSurface, + aRangeOnPairSurface, + hasLowerLimitYaw, + aLowerLimitYaw, + hasUpperLimitYaw, + aUpperLimitYaw, + hasLowerLimitPitch, + aLowerLimitPitch, + hasUpperLimitPitch, + aUpperLimitPitch, + hasLowerLimitRoll, + aLowerLimitRoll, + hasUpperLimitRoll, + aUpperLimitRoll); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWPointOnSurfacePairWithRange::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_PointOnSurfacePairWithRange)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of PointOnSurfacePair + + theSW.Send (theEnt->PairSurface()); + + // Own fields of PointOnSurfacePairWithRange + + theSW.Send (theEnt->RangeOnPairSurface()); + + if ( theEnt->HasLowerLimitYaw() ) { + theSW.Send (theEnt->LowerLimitYaw()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitYaw() ) { + theSW.Send (theEnt->UpperLimitYaw()); + } + else theSW.SendUndef(); + + if ( theEnt->HasLowerLimitPitch() ) { + theSW.Send (theEnt->LowerLimitPitch()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitPitch() ) { + theSW.Send (theEnt->UpperLimitPitch()); + } + else theSW.SendUndef(); + + if ( theEnt->HasLowerLimitRoll() ) { + theSW.Send (theEnt->LowerLimitRoll()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitRoll() ) { + theSW.Send (theEnt->UpperLimitRoll()); + } + else theSW.SendUndef(); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWPointOnSurfacePairWithRange::Share (const Handle(StepKinematics_PointOnSurfacePairWithRange)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of PointOnSurfacePair + + iter.AddItem (theEnt->StepKinematics_PointOnSurfacePair::PairSurface()); + + // Own fields of PointOnSurfacePairWithRange + + iter.AddItem (theEnt->RangeOnPairSurface()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePairWithRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePairWithRange.hxx new file mode 100644 index 0000000000..45ed322ece --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePairWithRange.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWPointOnSurfacePairWithRange_HeaderFile_ +#define _RWStepKinematics_RWPointOnSurfacePairWithRange_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PointOnSurfacePairWithRange)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PointOnSurfacePairWithRange)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_PointOnSurfacePairWithRange)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWPointOnSurfacePairWithRange_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPrismaticPair.cxx b/src/RWStepKinematics/RWStepKinematics_RWPrismaticPair.cxx new file mode 100644 index 0000000000..74ba10d636 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPrismaticPair.cxx @@ -0,0 +1,180 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_PrismaticPair)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,12,theArch,"prismatic_pair") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of LowOrderKinematicPair + + Standard_Boolean aLowOrderKinematicPair_TX; + theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX); + + Standard_Boolean aLowOrderKinematicPair_TY; + theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY); + + Standard_Boolean aLowOrderKinematicPair_TZ; + theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ); + + Standard_Boolean aLowOrderKinematicPair_RX; + theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX); + + Standard_Boolean aLowOrderKinematicPair_RY; + theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY); + + Standard_Boolean aLowOrderKinematicPair_RZ; + theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWPrismaticPair::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_PrismaticPair)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of LowOrderKinematicPair + + theSW.SendBoolean (theEnt->TX()); + + theSW.SendBoolean (theEnt->TY()); + + theSW.SendBoolean (theEnt->TZ()); + + theSW.SendBoolean (theEnt->RX()); + + theSW.SendBoolean (theEnt->RY()); + + theSW.SendBoolean (theEnt->RZ()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWPrismaticPair::Share (const Handle(StepKinematics_PrismaticPair)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of LowOrderKinematicPair +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPrismaticPair.hxx b/src/RWStepKinematics/RWStepKinematics_RWPrismaticPair.hxx new file mode 100644 index 0000000000..e685a6ad4e --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPrismaticPair.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWPrismaticPair_HeaderFile_ +#define _RWStepKinematics_RWPrismaticPair_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PrismaticPair)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PrismaticPair)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_PrismaticPair)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWPrismaticPair_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPrismaticPairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWPrismaticPairValue.cxx new file mode 100644 index 0000000000..6c9d9052be --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPrismaticPairValue.cxx @@ -0,0 +1,103 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_PrismaticPairValue)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,3,theArch,"prismatic_pair_value") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of PairValue + + Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair; + theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair); + + // Own fields of PrismaticPairValue + + Standard_Real aActualTranslation; + theData->ReadReal (theNum, 3, "actual_translation", theArch, aActualTranslation); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aPairValue_AppliesToPair, + aActualTranslation); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWPrismaticPairValue::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_PrismaticPairValue)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Own fields of PairValue + + theSW.Send (theEnt->AppliesToPair()); + + // Own fields of PrismaticPairValue + + theSW.Send (theEnt->ActualTranslation()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWPrismaticPairValue::Share (const Handle(StepKinematics_PrismaticPairValue)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of PairValue + + iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair()); + + // Own fields of PrismaticPairValue +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPrismaticPairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWPrismaticPairValue.hxx new file mode 100644 index 0000000000..fee0c19933 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPrismaticPairValue.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWPrismaticPairValue_HeaderFile_ +#define _RWStepKinematics_RWPrismaticPairValue_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PrismaticPairValue)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PrismaticPairValue)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_PrismaticPairValue)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWPrismaticPairValue_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWPrismaticPairWithRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWPrismaticPairWithRange.cxx new file mode 100644 index 0000000000..85decffdd9 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPrismaticPairWithRange.cxx @@ -0,0 +1,221 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_PrismaticPairWithRange)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,14,theArch,"prismatic_pair_with_range") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of LowOrderKinematicPair + + Standard_Boolean aLowOrderKinematicPair_TX; + theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX); + + Standard_Boolean aLowOrderKinematicPair_TY; + theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY); + + Standard_Boolean aLowOrderKinematicPair_TZ; + theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ); + + Standard_Boolean aLowOrderKinematicPair_RX; + theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX); + + Standard_Boolean aLowOrderKinematicPair_RY; + theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY); + + Standard_Boolean aLowOrderKinematicPair_RZ; + theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ); + + // Own fields of PrismaticPairWithRange + + Standard_Real aLowerLimitActualTranslation; + Standard_Boolean hasLowerLimitActualTranslation = Standard_True; + if ( theData->IsParamDefined (theNum,13) ) { + theData->ReadReal (theNum, 13, "lower_limit_actual_translation", theArch, aLowerLimitActualTranslation); + } + else { + hasLowerLimitActualTranslation = Standard_False; + aLowerLimitActualTranslation = 0; + } + + Standard_Real aUpperLimitActualTranslation; + Standard_Boolean hasUpperLimitActualTranslation = Standard_True; + if ( theData->IsParamDefined (theNum,14) ) { + theData->ReadReal (theNum, 14, "upper_limit_actual_translation", theArch, aUpperLimitActualTranslation); + } + else { + hasUpperLimitActualTranslation = Standard_False; + aUpperLimitActualTranslation = 0; + } + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ, + hasLowerLimitActualTranslation, + aLowerLimitActualTranslation, + hasUpperLimitActualTranslation, + aUpperLimitActualTranslation); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWPrismaticPairWithRange::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_PrismaticPairWithRange)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of LowOrderKinematicPair + + theSW.SendBoolean (theEnt->TX()); + + theSW.SendBoolean (theEnt->TY()); + + theSW.SendBoolean (theEnt->TZ()); + + theSW.SendBoolean (theEnt->RX()); + + theSW.SendBoolean (theEnt->RY()); + + theSW.SendBoolean (theEnt->RZ()); + + // Own fields of PrismaticPairWithRange + + if ( theEnt->HasLowerLimitActualTranslation() ) { + theSW.Send (theEnt->LowerLimitActualTranslation()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitActualTranslation() ) { + theSW.Send (theEnt->UpperLimitActualTranslation()); + } + else theSW.SendUndef(); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWPrismaticPairWithRange::Share (const Handle(StepKinematics_PrismaticPairWithRange)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of LowOrderKinematicPair + + // Own fields of PrismaticPairWithRange +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWPrismaticPairWithRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWPrismaticPairWithRange.hxx new file mode 100644 index 0000000000..665069283e --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWPrismaticPairWithRange.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWPrismaticPairWithRange_HeaderFile_ +#define _RWStepKinematics_RWPrismaticPairWithRange_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PrismaticPairWithRange)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PrismaticPairWithRange)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_PrismaticPairWithRange)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWPrismaticPairWithRange_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWProductDefinitionKinematics.cxx b/src/RWStepKinematics/RWStepKinematics_RWProductDefinitionKinematics.cxx new file mode 100644 index 0000000000..ef3b100e2f --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWProductDefinitionKinematics.cxx @@ -0,0 +1,101 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_ProductDefinitionKinematics)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,3,theArch,"product_definition_kinematics") ) return; + + // Inherited fields of PropertyDefinition + + Handle(TCollection_HAsciiString) aPropertyDefinition_Name; + theData->ReadString (theNum, 1, "property_definition.name", theArch, aPropertyDefinition_Name); + + Handle(TCollection_HAsciiString) aPropertyDefinition_Description; + Standard_Boolean hasPropertyDefinition_Description = Standard_True; + if ( theData->IsParamDefined (theNum,2) ) { + theData->ReadString (theNum, 2, "property_definition.description", theArch, aPropertyDefinition_Description); + } + else { + hasPropertyDefinition_Description = Standard_False; + aPropertyDefinition_Description.Nullify(); + } + + StepRepr_CharacterizedDefinition aPropertyDefinition_Definition; + theData->ReadEntity (theNum, 3, "property_definition.definition", theArch, aPropertyDefinition_Definition); + + // Initialize entity + theEnt->Init(aPropertyDefinition_Name, + hasPropertyDefinition_Description, + aPropertyDefinition_Description, + aPropertyDefinition_Definition); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWProductDefinitionKinematics::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_ProductDefinitionKinematics)& theEnt) const +{ + + // Own fields of PropertyDefinition + + theSW.Send (theEnt->Name()); + + if ( theEnt->HasDescription() ) { + theSW.Send (theEnt->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->Definition().Value()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWProductDefinitionKinematics::Share (const Handle(StepKinematics_ProductDefinitionKinematics)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of PropertyDefinition + + iter.AddItem (theEnt->StepRepr_PropertyDefinition::Definition().Value()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWProductDefinitionKinematics.hxx b/src/RWStepKinematics/RWStepKinematics_RWProductDefinitionKinematics.hxx new file mode 100644 index 0000000000..3d5796fbc6 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWProductDefinitionKinematics.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWProductDefinitionKinematics_HeaderFile_ +#define _RWStepKinematics_RWProductDefinitionKinematics_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_ProductDefinitionKinematics)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_ProductDefinitionKinematics)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_ProductDefinitionKinematics)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWProductDefinitionKinematics_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWProductDefinitionRelationshipKinematics.cxx b/src/RWStepKinematics/RWStepKinematics_RWProductDefinitionRelationshipKinematics.cxx new file mode 100644 index 0000000000..b191df446c --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWProductDefinitionRelationshipKinematics.cxx @@ -0,0 +1,101 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_ProductDefinitionRelationshipKinematics)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,3,theArch,"product_definition_relationship_kinematics") ) return; + + // Inherited fields of PropertyDefinition + + Handle(TCollection_HAsciiString) aPropertyDefinition_Name; + theData->ReadString (theNum, 1, "property_definition.name", theArch, aPropertyDefinition_Name); + + Handle(TCollection_HAsciiString) aPropertyDefinition_Description; + Standard_Boolean hasPropertyDefinition_Description = Standard_True; + if ( theData->IsParamDefined (theNum,2) ) { + theData->ReadString (theNum, 2, "property_definition.description", theArch, aPropertyDefinition_Description); + } + else { + hasPropertyDefinition_Description = Standard_False; + aPropertyDefinition_Description.Nullify(); + } + + StepRepr_CharacterizedDefinition aPropertyDefinition_Definition; + theData->ReadEntity (theNum, 3, "property_definition.definition", theArch, aPropertyDefinition_Definition); + + // Initialize entity + theEnt->Init(aPropertyDefinition_Name, + hasPropertyDefinition_Description, + aPropertyDefinition_Description, + aPropertyDefinition_Definition); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWProductDefinitionRelationshipKinematics::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_ProductDefinitionRelationshipKinematics)& theEnt) const +{ + + // Own fields of PropertyDefinition + + theSW.Send (theEnt->Name()); + + if ( theEnt->HasDescription() ) { + theSW.Send (theEnt->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->Definition().Value()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWProductDefinitionRelationshipKinematics::Share (const Handle(StepKinematics_ProductDefinitionRelationshipKinematics)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of PropertyDefinition + + iter.AddItem (theEnt->StepRepr_PropertyDefinition::Definition().Value()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWProductDefinitionRelationshipKinematics.hxx b/src/RWStepKinematics/RWStepKinematics_RWProductDefinitionRelationshipKinematics.hxx new file mode 100644 index 0000000000..0fc3a20722 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWProductDefinitionRelationshipKinematics.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWProductDefinitionRelationshipKinematics_HeaderFile_ +#define _RWStepKinematics_RWProductDefinitionRelationshipKinematics_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_ProductDefinitionRelationshipKinematics)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_ProductDefinitionRelationshipKinematics)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_ProductDefinitionRelationshipKinematics)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWProductDefinitionRelationshipKinematics_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPair.cxx b/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPair.cxx new file mode 100644 index 0000000000..ebbd68bbf9 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPair.cxx @@ -0,0 +1,150 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_RackAndPinionPair)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,7,theArch,"rack_and_pinion_pair") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Own fields of RackAndPinionPair + + Standard_Real aPinionRadius; + theData->ReadReal (theNum, 7, "pinion_radius", theArch, aPinionRadius); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aPinionRadius); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWRackAndPinionPair::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_RackAndPinionPair)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of RackAndPinionPair + + theSW.Send (theEnt->PinionRadius()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWRackAndPinionPair::Share (const Handle(StepKinematics_RackAndPinionPair)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Own fields of RackAndPinionPair +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPair.hxx b/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPair.hxx new file mode 100644 index 0000000000..1032ae3701 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPair.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWRackAndPinionPair_HeaderFile_ +#define _RWStepKinematics_RWRackAndPinionPair_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_RackAndPinionPair)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_RackAndPinionPair)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_RackAndPinionPair)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWRackAndPinionPair_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPairValue.cxx new file mode 100644 index 0000000000..650d333c57 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPairValue.cxx @@ -0,0 +1,103 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_RackAndPinionPairValue)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,3,theArch,"rack_and_pinion_pair_value") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of PairValue + + Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair; + theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair); + + // Own fields of RackAndPinionPairValue + + Standard_Real aActualDisplacement; + theData->ReadReal (theNum, 3, "actual_displacement", theArch, aActualDisplacement); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aPairValue_AppliesToPair, + aActualDisplacement); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWRackAndPinionPairValue::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_RackAndPinionPairValue)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Own fields of PairValue + + theSW.Send (theEnt->AppliesToPair()); + + // Own fields of RackAndPinionPairValue + + theSW.Send (theEnt->ActualDisplacement()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWRackAndPinionPairValue::Share (const Handle(StepKinematics_RackAndPinionPairValue)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of PairValue + + iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair()); + + // Own fields of RackAndPinionPairValue +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPairValue.hxx new file mode 100644 index 0000000000..e7cbc804de --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPairValue.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWRackAndPinionPairValue_HeaderFile_ +#define _RWStepKinematics_RWRackAndPinionPairValue_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_RackAndPinionPairValue)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_RackAndPinionPairValue)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_RackAndPinionPairValue)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWRackAndPinionPairValue_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPairWithRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPairWithRange.cxx new file mode 100644 index 0000000000..b97d8ba6f6 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPairWithRange.cxx @@ -0,0 +1,190 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_RackAndPinionPairWithRange)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,9,theArch,"rack_and_pinion_pair_with_range") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of RackAndPinionPair + + Standard_Real aRackAndPinionPair_PinionRadius; + theData->ReadReal (theNum, 7, "rack_and_pinion_pair.pinion_radius", theArch, aRackAndPinionPair_PinionRadius); + + // Own fields of RackAndPinionPairWithRange + + Standard_Real aLowerLimitRackDisplacement; + Standard_Boolean hasLowerLimitRackDisplacement = Standard_True; + if ( theData->IsParamDefined (theNum,8) ) { + theData->ReadReal (theNum, 8, "lower_limit_rack_displacement", theArch, aLowerLimitRackDisplacement); + } + else { + hasLowerLimitRackDisplacement = Standard_False; + aLowerLimitRackDisplacement = 0; + } + + Standard_Real aUpperLimitRackDisplacement; + Standard_Boolean hasUpperLimitRackDisplacement = Standard_True; + if ( theData->IsParamDefined (theNum,9) ) { + theData->ReadReal (theNum, 9, "upper_limit_rack_displacement", theArch, aUpperLimitRackDisplacement); + } + else { + hasUpperLimitRackDisplacement = Standard_False; + aUpperLimitRackDisplacement = 0; + } + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aRackAndPinionPair_PinionRadius, + hasLowerLimitRackDisplacement, + aLowerLimitRackDisplacement, + hasUpperLimitRackDisplacement, + aUpperLimitRackDisplacement); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWRackAndPinionPairWithRange::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_RackAndPinionPairWithRange)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of RackAndPinionPair + + theSW.Send (theEnt->PinionRadius()); + + // Own fields of RackAndPinionPairWithRange + + if ( theEnt->HasLowerLimitRackDisplacement() ) { + theSW.Send (theEnt->LowerLimitRackDisplacement()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitRackDisplacement() ) { + theSW.Send (theEnt->UpperLimitRackDisplacement()); + } + else theSW.SendUndef(); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWRackAndPinionPairWithRange::Share (const Handle(StepKinematics_RackAndPinionPairWithRange)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of RackAndPinionPair + + // Own fields of RackAndPinionPairWithRange +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPairWithRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPairWithRange.hxx new file mode 100644 index 0000000000..5179abfaa4 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPairWithRange.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWRackAndPinionPairWithRange_HeaderFile_ +#define _RWStepKinematics_RWRackAndPinionPairWithRange_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_RackAndPinionPairWithRange)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_RackAndPinionPairWithRange)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_RackAndPinionPairWithRange)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWRackAndPinionPairWithRange_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWRevolutePair.cxx b/src/RWStepKinematics/RWStepKinematics_RWRevolutePair.cxx new file mode 100644 index 0000000000..5b5686c251 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRevolutePair.cxx @@ -0,0 +1,180 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_RevolutePair)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,12,theArch,"revolute_pair") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of LowOrderKinematicPair + + Standard_Boolean aLowOrderKinematicPair_TX; + theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX); + + Standard_Boolean aLowOrderKinematicPair_TY; + theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY); + + Standard_Boolean aLowOrderKinematicPair_TZ; + theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ); + + Standard_Boolean aLowOrderKinematicPair_RX; + theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX); + + Standard_Boolean aLowOrderKinematicPair_RY; + theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY); + + Standard_Boolean aLowOrderKinematicPair_RZ; + theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWRevolutePair::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_RevolutePair)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of LowOrderKinematicPair + + theSW.SendBoolean (theEnt->TX()); + + theSW.SendBoolean (theEnt->TY()); + + theSW.SendBoolean (theEnt->TZ()); + + theSW.SendBoolean (theEnt->RX()); + + theSW.SendBoolean (theEnt->RY()); + + theSW.SendBoolean (theEnt->RZ()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWRevolutePair::Share (const Handle(StepKinematics_RevolutePair)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of LowOrderKinematicPair +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWRevolutePair.hxx b/src/RWStepKinematics/RWStepKinematics_RWRevolutePair.hxx new file mode 100644 index 0000000000..b4b3d40037 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRevolutePair.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWRevolutePair_HeaderFile_ +#define _RWStepKinematics_RWRevolutePair_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_RevolutePair)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_RevolutePair)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_RevolutePair)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWRevolutePair_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWRevolutePairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWRevolutePairValue.cxx new file mode 100644 index 0000000000..98ae04859b --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRevolutePairValue.cxx @@ -0,0 +1,103 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_RevolutePairValue)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,3,theArch,"revolute_pair_value") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of PairValue + + Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair; + theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair); + + // Own fields of RevolutePairValue + + Standard_Real aActualRotation; + theData->ReadReal (theNum, 3, "actual_rotation", theArch, aActualRotation); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aPairValue_AppliesToPair, + aActualRotation); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWRevolutePairValue::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_RevolutePairValue)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Own fields of PairValue + + theSW.Send (theEnt->AppliesToPair()); + + // Own fields of RevolutePairValue + + theSW.Send (theEnt->ActualRotation()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWRevolutePairValue::Share (const Handle(StepKinematics_RevolutePairValue)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of PairValue + + iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair()); + + // Own fields of RevolutePairValue +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWRevolutePairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWRevolutePairValue.hxx new file mode 100644 index 0000000000..eb38224ca6 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRevolutePairValue.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWRevolutePairValue_HeaderFile_ +#define _RWStepKinematics_RWRevolutePairValue_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_RevolutePairValue)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_RevolutePairValue)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_RevolutePairValue)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWRevolutePairValue_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWRevolutePairWithRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWRevolutePairWithRange.cxx new file mode 100644 index 0000000000..6113928edd --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRevolutePairWithRange.cxx @@ -0,0 +1,221 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_RevolutePairWithRange)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,14,theArch,"revolute_pair_with_range") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of LowOrderKinematicPair + + Standard_Boolean aLowOrderKinematicPair_TX; + theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX); + + Standard_Boolean aLowOrderKinematicPair_TY; + theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY); + + Standard_Boolean aLowOrderKinematicPair_TZ; + theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ); + + Standard_Boolean aLowOrderKinematicPair_RX; + theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX); + + Standard_Boolean aLowOrderKinematicPair_RY; + theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY); + + Standard_Boolean aLowOrderKinematicPair_RZ; + theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ); + + // Own fields of RevolutePairWithRange + + Standard_Real aLowerLimitActualRotation; + Standard_Boolean hasLowerLimitActualRotation = Standard_True; + if ( theData->IsParamDefined (theNum,13) ) { + theData->ReadReal (theNum, 13, "lower_limit_actual_rotation", theArch, aLowerLimitActualRotation); + } + else { + hasLowerLimitActualRotation = Standard_False; + aLowerLimitActualRotation = 0; + } + + Standard_Real aUpperLimitActualRotation; + Standard_Boolean hasUpperLimitActualRotation = Standard_True; + if ( theData->IsParamDefined (theNum,14) ) { + theData->ReadReal (theNum, 14, "upper_limit_actual_rotation", theArch, aUpperLimitActualRotation); + } + else { + hasUpperLimitActualRotation = Standard_False; + aUpperLimitActualRotation = 0; + } + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ, + hasLowerLimitActualRotation, + aLowerLimitActualRotation, + hasUpperLimitActualRotation, + aUpperLimitActualRotation); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWRevolutePairWithRange::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_RevolutePairWithRange)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of LowOrderKinematicPair + + theSW.SendBoolean (theEnt->TX()); + + theSW.SendBoolean (theEnt->TY()); + + theSW.SendBoolean (theEnt->TZ()); + + theSW.SendBoolean (theEnt->RX()); + + theSW.SendBoolean (theEnt->RY()); + + theSW.SendBoolean (theEnt->RZ()); + + // Own fields of RevolutePairWithRange + + if ( theEnt->HasLowerLimitActualRotation() ) { + theSW.Send (theEnt->LowerLimitActualRotation()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitActualRotation() ) { + theSW.Send (theEnt->UpperLimitActualRotation()); + } + else theSW.SendUndef(); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWRevolutePairWithRange::Share (const Handle(StepKinematics_RevolutePairWithRange)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of LowOrderKinematicPair + + // Own fields of RevolutePairWithRange +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWRevolutePairWithRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWRevolutePairWithRange.hxx new file mode 100644 index 0000000000..d594494186 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRevolutePairWithRange.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWRevolutePairWithRange_HeaderFile_ +#define _RWStepKinematics_RWRevolutePairWithRange_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_RevolutePairWithRange)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_RevolutePairWithRange)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_RevolutePairWithRange)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWRevolutePairWithRange_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWRigidLinkRepresentation.cxx b/src/RWStepKinematics/RWStepKinematics_RWRigidLinkRepresentation.cxx new file mode 100644 index 0000000000..3b486573f9 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRigidLinkRepresentation.cxx @@ -0,0 +1,127 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//======================================================================= +//function : RWStepKinematics_RWRigidLinkRepresentation +//purpose : +//======================================================================= +RWStepKinematics_RWRigidLinkRepresentation::RWStepKinematics_RWRigidLinkRepresentation() {} + + +//======================================================================= +//function : ReadStep +//purpose : +//======================================================================= +void RWStepKinematics_RWRigidLinkRepresentation::ReadStep (const Handle(StepData_StepReaderData)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_RigidLinkRepresentation)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,4,theArch,"rigid_link_representation") ) return; + + // Inherited fields of Representation + + Handle(TCollection_HAsciiString) aRepresentation_Name; + theData->ReadString (theNum, 1, "representation.name", theArch, aRepresentation_Name); + + Handle(StepRepr_HArray1OfRepresentationItem) aRepresentation_Items; + Standard_Integer sub2 = 0; + if ( theData->ReadSubList (theNum, 2, "representation.items", theArch, sub2) ) { + Standard_Integer nb0 = theData->NbParams(sub2); + aRepresentation_Items = new StepRepr_HArray1OfRepresentationItem (1, nb0); + Standard_Integer num2 = sub2; + for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) { + Handle(StepRepr_RepresentationItem) anIt0; + theData->ReadEntity (num2, i0, "representation_item", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), anIt0); + aRepresentation_Items->SetValue(i0, anIt0); + } + } + + Handle(StepRepr_RepresentationContext) aRepresentation_ContextOfItems; + theData->ReadEntity (theNum, 3, "representation.context_of_items", theArch, STANDARD_TYPE(StepRepr_RepresentationContext), aRepresentation_ContextOfItems); + + // Inherited fields of KinematicLinkRepresentation + + Handle(StepKinematics_KinematicLink) aKinematicLinkRepresentation_RepresentedLink; + theData->ReadEntity (theNum, 4, "kinematic_link_representation.represented_link", theArch, STANDARD_TYPE(StepKinematics_KinematicLink), aKinematicLinkRepresentation_RepresentedLink); + + // Initialize entity + theEnt->Init(aRepresentation_Name, + aRepresentation_Items, + aRepresentation_ContextOfItems, + aKinematicLinkRepresentation_RepresentedLink); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWRigidLinkRepresentation::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_RigidLinkRepresentation)& theEnt) const +{ + + // Own fields of Representation + + theSW.Send (theEnt->Name()); + + theSW.OpenSub(); + for (Standard_Integer i1=1; i1 <= theEnt->Items()->Length(); i1++ ) { + Handle(StepRepr_RepresentationItem) Var0 = theEnt->Items()->Value(i1); + theSW.Send (Var0); + } + theSW.CloseSub(); + + theSW.Send (theEnt->ContextOfItems()); + + // Own fields of KinematicLinkRepresentation + + theSW.Send (theEnt->RepresentedLink()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWRigidLinkRepresentation::Share (const Handle(StepKinematics_RigidLinkRepresentation)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of Representation + + for (Standard_Integer i1=1; i1 <= theEnt->StepRepr_Representation::Items()->Length(); i1++ ) { + Handle(StepRepr_RepresentationItem) Var0 = theEnt->StepRepr_Representation::Items()->Value(i1); + iter.AddItem (Var0); + } + + iter.AddItem (theEnt->StepRepr_Representation::ContextOfItems()); + + // Inherited fields of KinematicLinkRepresentation + + iter.AddItem (theEnt->StepKinematics_KinematicLinkRepresentation::RepresentedLink()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWRigidLinkRepresentation.hxx b/src/RWStepKinematics/RWStepKinematics_RWRigidLinkRepresentation.hxx new file mode 100644 index 0000000000..0f95af72b0 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRigidLinkRepresentation.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWRigidLinkRepresentation_HeaderFile_ +#define _RWStepKinematics_RWRigidLinkRepresentation_HeaderFile_ + +#include +#include +#include + +class StepData_StepReaderData; +class Interface_Check; +class StepData_StepWriter; +class Interface_EntityIterator; +class StepKinematics_RigidLinkRepresentation; + +//! Read & Write tool for RigidLinkRepresentation +class RWStepKinematics_RWRigidLinkRepresentation +{ +public: + + DEFINE_STANDARD_ALLOC + + Standard_EXPORT RWStepKinematics_RWRigidLinkRepresentation(); + + Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_RigidLinkRepresentation)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_RigidLinkRepresentation)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_RigidLinkRepresentation)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWRigidLinkRepresentation_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWRollingCurvePair.cxx b/src/RWStepKinematics/RWStepKinematics_RWRollingCurvePair.cxx new file mode 100644 index 0000000000..aaec07c51d --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRollingCurvePair.cxx @@ -0,0 +1,167 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_RollingCurvePair)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,9,theArch,"rolling_curve_pair") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of PlanarCurvePair + + Handle(StepGeom_Curve) aPlanarCurvePair_Curve1; + theData->ReadEntity (theNum, 7, "planar_curve_pair.curve1", theArch, STANDARD_TYPE(StepGeom_Curve), aPlanarCurvePair_Curve1); + + Handle(StepGeom_Curve) aPlanarCurvePair_Curve2; + theData->ReadEntity (theNum, 8, "planar_curve_pair.curve2", theArch, STANDARD_TYPE(StepGeom_Curve), aPlanarCurvePair_Curve2); + + Standard_Boolean aPlanarCurvePair_Orientation; + theData->ReadBoolean (theNum, 9, "planar_curve_pair.orientation", theArch, aPlanarCurvePair_Orientation); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aPlanarCurvePair_Curve1, + aPlanarCurvePair_Curve2, + aPlanarCurvePair_Orientation); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWRollingCurvePair::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_RollingCurvePair)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of PlanarCurvePair + + theSW.Send (theEnt->Curve1()); + + theSW.Send (theEnt->Curve2()); + + theSW.SendBoolean (theEnt->Orientation()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWRollingCurvePair::Share (const Handle(StepKinematics_RollingCurvePair)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of PlanarCurvePair + + iter.AddItem (theEnt->StepKinematics_PlanarCurvePair::Curve1()); + + iter.AddItem (theEnt->StepKinematics_PlanarCurvePair::Curve2()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWRollingCurvePair.hxx b/src/RWStepKinematics/RWStepKinematics_RWRollingCurvePair.hxx new file mode 100644 index 0000000000..6b4e6c1597 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRollingCurvePair.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWRollingCurvePair_HeaderFile_ +#define _RWStepKinematics_RWRollingCurvePair_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_RollingCurvePair)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_RollingCurvePair)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_RollingCurvePair)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWRollingCurvePair_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWRollingCurvePairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWRollingCurvePairValue.cxx new file mode 100644 index 0000000000..b608d04469 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRollingCurvePairValue.cxx @@ -0,0 +1,105 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_RollingCurvePairValue)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,3,theArch,"rolling_curve_pair_value") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of PairValue + + Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair; + theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair); + + // Own fields of RollingCurvePairValue + + Handle(StepGeom_PointOnCurve) aActualPointOnCurve1; + theData->ReadEntity (theNum, 3, "actual_point_on_curve1", theArch, STANDARD_TYPE(StepGeom_PointOnCurve), aActualPointOnCurve1); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aPairValue_AppliesToPair, + aActualPointOnCurve1); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWRollingCurvePairValue::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_RollingCurvePairValue)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Own fields of PairValue + + theSW.Send (theEnt->AppliesToPair()); + + // Own fields of RollingCurvePairValue + + theSW.Send (theEnt->ActualPointOnCurve1()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWRollingCurvePairValue::Share (const Handle(StepKinematics_RollingCurvePairValue)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of PairValue + + iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair()); + + // Own fields of RollingCurvePairValue + + iter.AddItem (theEnt->ActualPointOnCurve1()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWRollingCurvePairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWRollingCurvePairValue.hxx new file mode 100644 index 0000000000..9ec3e53661 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRollingCurvePairValue.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWRollingCurvePairValue_HeaderFile_ +#define _RWStepKinematics_RWRollingCurvePairValue_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_RollingCurvePairValue)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_RollingCurvePairValue)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_RollingCurvePairValue)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWRollingCurvePairValue_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWRollingSurfacePair.cxx b/src/RWStepKinematics/RWStepKinematics_RWRollingSurfacePair.cxx new file mode 100644 index 0000000000..5bf922c282 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRollingSurfacePair.cxx @@ -0,0 +1,167 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_RollingSurfacePair)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,9,theArch,"rolling_surface_pair") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of SurfacePair + + Handle(StepGeom_Surface) aSurfacePair_Surface1; + theData->ReadEntity (theNum, 7, "surface_pair.surface1", theArch, STANDARD_TYPE(StepGeom_Surface), aSurfacePair_Surface1); + + Handle(StepGeom_Surface) aSurfacePair_Surface2; + theData->ReadEntity (theNum, 8, "surface_pair.surface2", theArch, STANDARD_TYPE(StepGeom_Surface), aSurfacePair_Surface2); + + Standard_Boolean aSurfacePair_Orientation; + theData->ReadBoolean (theNum, 9, "surface_pair.orientation", theArch, aSurfacePair_Orientation); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aSurfacePair_Surface1, + aSurfacePair_Surface2, + aSurfacePair_Orientation); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWRollingSurfacePair::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_RollingSurfacePair)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of SurfacePair + + theSW.Send (theEnt->Surface1()); + + theSW.Send (theEnt->Surface2()); + + theSW.SendBoolean (theEnt->Orientation()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWRollingSurfacePair::Share (const Handle(StepKinematics_RollingSurfacePair)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of SurfacePair + + iter.AddItem (theEnt->StepKinematics_SurfacePair::Surface1()); + + iter.AddItem (theEnt->StepKinematics_SurfacePair::Surface2()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWRollingSurfacePair.hxx b/src/RWStepKinematics/RWStepKinematics_RWRollingSurfacePair.hxx new file mode 100644 index 0000000000..491eda205b --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRollingSurfacePair.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWRollingSurfacePair_HeaderFile_ +#define _RWStepKinematics_RWRollingSurfacePair_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_RollingSurfacePair)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_RollingSurfacePair)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_RollingSurfacePair)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWRollingSurfacePair_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWRollingSurfacePairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWRollingSurfacePairValue.cxx new file mode 100644 index 0000000000..78851c7ee8 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRollingSurfacePairValue.cxx @@ -0,0 +1,112 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#include +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_RollingSurfacePairValue)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,4,theArch,"rolling_surface_pair_value") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of PairValue + + Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair; + theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair); + + // Own fields of RollingSurfacePairValue + + Handle(StepGeom_PointOnSurface) aActualPointOnSurface; + theData->ReadEntity (theNum, 3, "actual_point_on_surface", theArch, STANDARD_TYPE(StepGeom_PointOnSurface), aActualPointOnSurface); + + Standard_Real aActualRotation; + theData->ReadReal (theNum, 4, "actual_rotation", theArch, aActualRotation); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aPairValue_AppliesToPair, + aActualPointOnSurface, + aActualRotation); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWRollingSurfacePairValue::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_RollingSurfacePairValue)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Own fields of PairValue + + theSW.Send (theEnt->AppliesToPair()); + + // Own fields of RollingSurfacePairValue + + theSW.Send (theEnt->ActualPointOnSurface()); + + theSW.Send (theEnt->ActualRotation()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWRollingSurfacePairValue::Share (const Handle(StepKinematics_RollingSurfacePairValue)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of PairValue + + iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair()); + + // Own fields of RollingSurfacePairValue + + iter.AddItem (theEnt->ActualPointOnSurface()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWRollingSurfacePairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWRollingSurfacePairValue.hxx new file mode 100644 index 0000000000..5ae75477ad --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRollingSurfacePairValue.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWRollingSurfacePairValue_HeaderFile_ +#define _RWStepKinematics_RWRollingSurfacePairValue_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_RollingSurfacePairValue)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_RollingSurfacePairValue)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_RollingSurfacePairValue)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWRollingSurfacePairValue_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWRotationAboutDirection.cxx b/src/RWStepKinematics/RWStepKinematics_RWRotationAboutDirection.cxx new file mode 100644 index 0000000000..65f3109391 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRotationAboutDirection.cxx @@ -0,0 +1,97 @@ +// Created on : Sat May 02 12:41:14 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_RotationAboutDirection)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,3,theArch,"rotation_about_direction") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Own fields of RotationAboutDirection + + Handle(StepGeom_Direction) aDirectionOfAxis; + theData->ReadEntity (theNum, 2, "direction_of_axis", theArch, STANDARD_TYPE(StepGeom_Direction), aDirectionOfAxis); + + Standard_Real aRotationAngle; + theData->ReadReal (theNum, 3, "rotation_angle", theArch, aRotationAngle); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aDirectionOfAxis, + aRotationAngle); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWRotationAboutDirection::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_RotationAboutDirection)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Own fields of RotationAboutDirection + + theSW.Send (theEnt->DirectionOfAxis()); + + theSW.Send (theEnt->RotationAngle()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWRotationAboutDirection::Share (const Handle(StepKinematics_RotationAboutDirection)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Own fields of RotationAboutDirection + + iter.AddItem (theEnt->DirectionOfAxis()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWRotationAboutDirection.hxx b/src/RWStepKinematics/RWStepKinematics_RWRotationAboutDirection.hxx new file mode 100644 index 0000000000..32e35d6490 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWRotationAboutDirection.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:14 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWRotationAboutDirection_HeaderFile_ +#define _RWStepKinematics_RWRotationAboutDirection_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_RotationAboutDirection)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_RotationAboutDirection)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_RotationAboutDirection)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWRotationAboutDirection_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWScrewPair.cxx b/src/RWStepKinematics/RWStepKinematics_RWScrewPair.cxx new file mode 100644 index 0000000000..3bed0f9004 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWScrewPair.cxx @@ -0,0 +1,150 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_ScrewPair)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,7,theArch,"screw_pair") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Own fields of ScrewPair + + Standard_Real aPitch; + theData->ReadReal (theNum, 7, "pitch", theArch, aPitch); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aPitch); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWScrewPair::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_ScrewPair)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of ScrewPair + + theSW.Send (theEnt->Pitch()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWScrewPair::Share (const Handle(StepKinematics_ScrewPair)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Own fields of ScrewPair +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWScrewPair.hxx b/src/RWStepKinematics/RWStepKinematics_RWScrewPair.hxx new file mode 100644 index 0000000000..379e7dd34b --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWScrewPair.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWScrewPair_HeaderFile_ +#define _RWStepKinematics_RWScrewPair_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_ScrewPair)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_ScrewPair)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_ScrewPair)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWScrewPair_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWScrewPairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWScrewPairValue.cxx new file mode 100644 index 0000000000..06343e4538 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWScrewPairValue.cxx @@ -0,0 +1,103 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_ScrewPairValue)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,3,theArch,"screw_pair_value") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of PairValue + + Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair; + theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair); + + // Own fields of ScrewPairValue + + Standard_Real aActualRotation; + theData->ReadReal (theNum, 3, "actual_rotation", theArch, aActualRotation); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aPairValue_AppliesToPair, + aActualRotation); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWScrewPairValue::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_ScrewPairValue)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Own fields of PairValue + + theSW.Send (theEnt->AppliesToPair()); + + // Own fields of ScrewPairValue + + theSW.Send (theEnt->ActualRotation()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWScrewPairValue::Share (const Handle(StepKinematics_ScrewPairValue)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of PairValue + + iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair()); + + // Own fields of ScrewPairValue +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWScrewPairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWScrewPairValue.hxx new file mode 100644 index 0000000000..916284e17f --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWScrewPairValue.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWScrewPairValue_HeaderFile_ +#define _RWStepKinematics_RWScrewPairValue_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_ScrewPairValue)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_ScrewPairValue)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_ScrewPairValue)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWScrewPairValue_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWScrewPairWithRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWScrewPairWithRange.cxx new file mode 100644 index 0000000000..7fe42958a9 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWScrewPairWithRange.cxx @@ -0,0 +1,190 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_ScrewPairWithRange)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,9,theArch,"screw_pair_with_range") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of ScrewPair + + Standard_Real aScrewPair_Pitch; + theData->ReadReal (theNum, 7, "screw_pair.pitch", theArch, aScrewPair_Pitch); + + // Own fields of ScrewPairWithRange + + Standard_Real aLowerLimitActualRotation; + Standard_Boolean hasLowerLimitActualRotation = Standard_True; + if ( theData->IsParamDefined (theNum,8) ) { + theData->ReadReal (theNum, 8, "lower_limit_actual_rotation", theArch, aLowerLimitActualRotation); + } + else { + hasLowerLimitActualRotation = Standard_False; + aLowerLimitActualRotation = 0; + } + + Standard_Real aUpperLimitActualRotation; + Standard_Boolean hasUpperLimitActualRotation = Standard_True; + if ( theData->IsParamDefined (theNum,9) ) { + theData->ReadReal (theNum, 9, "upper_limit_actual_rotation", theArch, aUpperLimitActualRotation); + } + else { + hasUpperLimitActualRotation = Standard_False; + aUpperLimitActualRotation = 0; + } + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aScrewPair_Pitch, + hasLowerLimitActualRotation, + aLowerLimitActualRotation, + hasUpperLimitActualRotation, + aUpperLimitActualRotation); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWScrewPairWithRange::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_ScrewPairWithRange)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of ScrewPair + + theSW.Send (theEnt->Pitch()); + + // Own fields of ScrewPairWithRange + + if ( theEnt->HasLowerLimitActualRotation() ) { + theSW.Send (theEnt->LowerLimitActualRotation()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitActualRotation() ) { + theSW.Send (theEnt->UpperLimitActualRotation()); + } + else theSW.SendUndef(); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWScrewPairWithRange::Share (const Handle(StepKinematics_ScrewPairWithRange)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of ScrewPair + + // Own fields of ScrewPairWithRange +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWScrewPairWithRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWScrewPairWithRange.hxx new file mode 100644 index 0000000000..8826564b04 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWScrewPairWithRange.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWScrewPairWithRange_HeaderFile_ +#define _RWStepKinematics_RWScrewPairWithRange_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_ScrewPairWithRange)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_ScrewPairWithRange)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_ScrewPairWithRange)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWScrewPairWithRange_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWSlidingCurvePair.cxx b/src/RWStepKinematics/RWStepKinematics_RWSlidingCurvePair.cxx new file mode 100644 index 0000000000..ce5613cc92 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSlidingCurvePair.cxx @@ -0,0 +1,167 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_SlidingCurvePair)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,9,theArch,"sliding_curve_pair") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of PlanarCurvePair + + Handle(StepGeom_Curve) aPlanarCurvePair_Curve1; + theData->ReadEntity (theNum, 7, "planar_curve_pair.curve1", theArch, STANDARD_TYPE(StepGeom_Curve), aPlanarCurvePair_Curve1); + + Handle(StepGeom_Curve) aPlanarCurvePair_Curve2; + theData->ReadEntity (theNum, 8, "planar_curve_pair.curve2", theArch, STANDARD_TYPE(StepGeom_Curve), aPlanarCurvePair_Curve2); + + Standard_Boolean aPlanarCurvePair_Orientation; + theData->ReadBoolean (theNum, 9, "planar_curve_pair.orientation", theArch, aPlanarCurvePair_Orientation); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aPlanarCurvePair_Curve1, + aPlanarCurvePair_Curve2, + aPlanarCurvePair_Orientation); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWSlidingCurvePair::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_SlidingCurvePair)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of PlanarCurvePair + + theSW.Send (theEnt->Curve1()); + + theSW.Send (theEnt->Curve2()); + + theSW.SendBoolean (theEnt->Orientation()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWSlidingCurvePair::Share (const Handle(StepKinematics_SlidingCurvePair)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of PlanarCurvePair + + iter.AddItem (theEnt->StepKinematics_PlanarCurvePair::Curve1()); + + iter.AddItem (theEnt->StepKinematics_PlanarCurvePair::Curve2()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWSlidingCurvePair.hxx b/src/RWStepKinematics/RWStepKinematics_RWSlidingCurvePair.hxx new file mode 100644 index 0000000000..6b319d28c3 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSlidingCurvePair.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWSlidingCurvePair_HeaderFile_ +#define _RWStepKinematics_RWSlidingCurvePair_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_SlidingCurvePair)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_SlidingCurvePair)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_SlidingCurvePair)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWSlidingCurvePair_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWSlidingCurvePairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWSlidingCurvePairValue.cxx new file mode 100644 index 0000000000..67eb5f9e1e --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSlidingCurvePairValue.cxx @@ -0,0 +1,113 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_SlidingCurvePairValue)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,4,theArch,"sliding_curve_pair_value") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of PairValue + + Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair; + theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair); + + // Own fields of SlidingCurvePairValue + + Handle(StepGeom_PointOnCurve) aActualPointOnCurve1; + theData->ReadEntity (theNum, 3, "actual_point_on_curve1", theArch, STANDARD_TYPE(StepGeom_PointOnCurve), aActualPointOnCurve1); + + Handle(StepGeom_PointOnCurve) aActualPointOnCurve2; + theData->ReadEntity (theNum, 4, "actual_point_on_curve2", theArch, STANDARD_TYPE(StepGeom_PointOnCurve), aActualPointOnCurve2); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aPairValue_AppliesToPair, + aActualPointOnCurve1, + aActualPointOnCurve2); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWSlidingCurvePairValue::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_SlidingCurvePairValue)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Own fields of PairValue + + theSW.Send (theEnt->AppliesToPair()); + + // Own fields of SlidingCurvePairValue + + theSW.Send (theEnt->ActualPointOnCurve1()); + + theSW.Send (theEnt->ActualPointOnCurve2()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWSlidingCurvePairValue::Share (const Handle(StepKinematics_SlidingCurvePairValue)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of PairValue + + iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair()); + + // Own fields of SlidingCurvePairValue + + iter.AddItem (theEnt->ActualPointOnCurve1()); + + iter.AddItem (theEnt->ActualPointOnCurve2()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWSlidingCurvePairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWSlidingCurvePairValue.hxx new file mode 100644 index 0000000000..262d7882a5 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSlidingCurvePairValue.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWSlidingCurvePairValue_HeaderFile_ +#define _RWStepKinematics_RWSlidingCurvePairValue_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_SlidingCurvePairValue)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_SlidingCurvePairValue)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_SlidingCurvePairValue)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWSlidingCurvePairValue_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWSlidingSurfacePair.cxx b/src/RWStepKinematics/RWStepKinematics_RWSlidingSurfacePair.cxx new file mode 100644 index 0000000000..857f5bb66e --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSlidingSurfacePair.cxx @@ -0,0 +1,167 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_SlidingSurfacePair)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,9,theArch,"sliding_surface_pair") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of SurfacePair + + Handle(StepGeom_Surface) aSurfacePair_Surface1; + theData->ReadEntity (theNum, 7, "surface_pair.surface1", theArch, STANDARD_TYPE(StepGeom_Surface), aSurfacePair_Surface1); + + Handle(StepGeom_Surface) aSurfacePair_Surface2; + theData->ReadEntity (theNum, 8, "surface_pair.surface2", theArch, STANDARD_TYPE(StepGeom_Surface), aSurfacePair_Surface2); + + Standard_Boolean aSurfacePair_Orientation; + theData->ReadBoolean (theNum, 9, "surface_pair.orientation", theArch, aSurfacePair_Orientation); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aSurfacePair_Surface1, + aSurfacePair_Surface2, + aSurfacePair_Orientation); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWSlidingSurfacePair::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_SlidingSurfacePair)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of SurfacePair + + theSW.Send (theEnt->Surface1()); + + theSW.Send (theEnt->Surface2()); + + theSW.SendBoolean (theEnt->Orientation()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWSlidingSurfacePair::Share (const Handle(StepKinematics_SlidingSurfacePair)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of SurfacePair + + iter.AddItem (theEnt->StepKinematics_SurfacePair::Surface1()); + + iter.AddItem (theEnt->StepKinematics_SurfacePair::Surface2()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWSlidingSurfacePair.hxx b/src/RWStepKinematics/RWStepKinematics_RWSlidingSurfacePair.hxx new file mode 100644 index 0000000000..dbc46e4ab1 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSlidingSurfacePair.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWSlidingSurfacePair_HeaderFile_ +#define _RWStepKinematics_RWSlidingSurfacePair_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_SlidingSurfacePair)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_SlidingSurfacePair)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_SlidingSurfacePair)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWSlidingSurfacePair_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWSlidingSurfacePairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWSlidingSurfacePairValue.cxx new file mode 100644 index 0000000000..fabe4bd53c --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSlidingSurfacePairValue.cxx @@ -0,0 +1,120 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#include +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_SlidingSurfacePairValue)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,5,theArch,"sliding_surface_pair_value") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of PairValue + + Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair; + theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair); + + // Own fields of SlidingSurfacePairValue + + Handle(StepGeom_PointOnSurface) aActualPointOnSurface1; + theData->ReadEntity (theNum, 3, "actual_point_on_surface1", theArch, STANDARD_TYPE(StepGeom_PointOnSurface), aActualPointOnSurface1); + + Handle(StepGeom_PointOnSurface) aActualPointOnSurface2; + theData->ReadEntity (theNum, 4, "actual_point_on_surface2", theArch, STANDARD_TYPE(StepGeom_PointOnSurface), aActualPointOnSurface2); + + Standard_Real aActualRotation; + theData->ReadReal (theNum, 5, "actual_rotation", theArch, aActualRotation); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aPairValue_AppliesToPair, + aActualPointOnSurface1, + aActualPointOnSurface2, + aActualRotation); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWSlidingSurfacePairValue::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_SlidingSurfacePairValue)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Own fields of PairValue + + theSW.Send (theEnt->AppliesToPair()); + + // Own fields of SlidingSurfacePairValue + + theSW.Send (theEnt->ActualPointOnSurface1()); + + theSW.Send (theEnt->ActualPointOnSurface2()); + + theSW.Send (theEnt->ActualRotation()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWSlidingSurfacePairValue::Share (const Handle(StepKinematics_SlidingSurfacePairValue)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of PairValue + + iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair()); + + // Own fields of SlidingSurfacePairValue + + iter.AddItem (theEnt->ActualPointOnSurface1()); + + iter.AddItem (theEnt->ActualPointOnSurface2()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWSlidingSurfacePairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWSlidingSurfacePairValue.hxx new file mode 100644 index 0000000000..278adb3d82 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSlidingSurfacePairValue.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWSlidingSurfacePairValue_HeaderFile_ +#define _RWStepKinematics_RWSlidingSurfacePairValue_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_SlidingSurfacePairValue)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_SlidingSurfacePairValue)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_SlidingSurfacePairValue)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWSlidingSurfacePairValue_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWSphericalPair.cxx b/src/RWStepKinematics/RWStepKinematics_RWSphericalPair.cxx new file mode 100644 index 0000000000..b37c6003d3 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSphericalPair.cxx @@ -0,0 +1,180 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_SphericalPair)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,12,theArch,"spherical_pair") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of LowOrderKinematicPair + + Standard_Boolean aLowOrderKinematicPair_TX; + theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX); + + Standard_Boolean aLowOrderKinematicPair_TY; + theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY); + + Standard_Boolean aLowOrderKinematicPair_TZ; + theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ); + + Standard_Boolean aLowOrderKinematicPair_RX; + theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX); + + Standard_Boolean aLowOrderKinematicPair_RY; + theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY); + + Standard_Boolean aLowOrderKinematicPair_RZ; + theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWSphericalPair::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_SphericalPair)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of LowOrderKinematicPair + + theSW.SendBoolean (theEnt->TX()); + + theSW.SendBoolean (theEnt->TY()); + + theSW.SendBoolean (theEnt->TZ()); + + theSW.SendBoolean (theEnt->RX()); + + theSW.SendBoolean (theEnt->RY()); + + theSW.SendBoolean (theEnt->RZ()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWSphericalPair::Share (const Handle(StepKinematics_SphericalPair)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of LowOrderKinematicPair +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWSphericalPair.hxx b/src/RWStepKinematics/RWStepKinematics_RWSphericalPair.hxx new file mode 100644 index 0000000000..9f9967c3e9 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSphericalPair.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWSphericalPair_HeaderFile_ +#define _RWStepKinematics_RWSphericalPair_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_SphericalPair)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_SphericalPair)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_SphericalPair)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWSphericalPair_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWSphericalPairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairValue.cxx new file mode 100644 index 0000000000..5bf44d0d2f --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairValue.cxx @@ -0,0 +1,133 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_SphericalPairValue)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,3,theArch,"spherical_pair_value") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of PairValue + + Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair; + theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair); + + + // Own fields of SphericalPairValue + StepKinematics_SpatialRotation aInputOrientation; + if (theData->SubListNumber(theNum, 3, Standard_True)) + { + Handle(TColStd_HArray1OfReal) aItems; + Standard_Integer nsub = 0; + if (theData->ReadSubList(theNum, 3, "items", theArch, nsub)) { + Standard_Integer nb = theData->NbParams(nsub); + aItems = new TColStd_HArray1OfReal(1, nb); + Standard_Integer num2 = nsub; + for (Standard_Integer i0 = 1; i0 <= nb; i0++) { + Standard_Real anIt0; + theData->ReadReal(num2, i0, "real", theArch, anIt0); + aItems->SetValue(i0, anIt0); + } + } + aInputOrientation.SetValue(aItems); + } + else + theData->ReadEntity (theNum, 3, "input_orientation", theArch, aInputOrientation); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aPairValue_AppliesToPair, + aInputOrientation); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWSphericalPairValue::WriteStep(StepData_StepWriter& theSW, + const Handle(StepKinematics_SphericalPairValue)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send(theEnt->Name()); + + // Own fields of PairValue + + theSW.Send(theEnt->AppliesToPair()); + + // Own fields of SphericalPairValue + + if (!theEnt->InputOrientation().YprRotation().IsNull()) + { + // Inherited field : YPR + theSW.OpenSub(); + for (Standard_Integer i = 1; i <= theEnt->InputOrientation().YprRotation()->Length(); i++) { + theSW.Send(theEnt->InputOrientation().YprRotation()->Value(i)); + } + theSW.CloseSub(); + } + else + theSW.Send(theEnt->InputOrientation().Value()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWSphericalPairValue::Share (const Handle(StepKinematics_SphericalPairValue)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of PairValue + + iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair()); + + // Own fields of SphericalPairValue + + if (!theEnt->InputOrientation().RotationAboutDirection().IsNull()) + iter.AddItem(theEnt->InputOrientation().Value()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWSphericalPairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairValue.hxx new file mode 100644 index 0000000000..f145b48a11 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairValue.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWSphericalPairValue_HeaderFile_ +#define _RWStepKinematics_RWSphericalPairValue_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_SphericalPairValue)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_SphericalPairValue)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_SphericalPairValue)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWSphericalPairValue_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithPin.cxx b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithPin.cxx new file mode 100644 index 0000000000..540f91b9cf --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithPin.cxx @@ -0,0 +1,180 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_SphericalPairWithPin)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,12,theArch,"spherical_pair_with_pin") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of LowOrderKinematicPair + + Standard_Boolean aLowOrderKinematicPair_TX; + theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX); + + Standard_Boolean aLowOrderKinematicPair_TY; + theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY); + + Standard_Boolean aLowOrderKinematicPair_TZ; + theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ); + + Standard_Boolean aLowOrderKinematicPair_RX; + theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX); + + Standard_Boolean aLowOrderKinematicPair_RY; + theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY); + + Standard_Boolean aLowOrderKinematicPair_RZ; + theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWSphericalPairWithPin::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_SphericalPairWithPin)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of LowOrderKinematicPair + + theSW.SendBoolean (theEnt->TX()); + + theSW.SendBoolean (theEnt->TY()); + + theSW.SendBoolean (theEnt->TZ()); + + theSW.SendBoolean (theEnt->RX()); + + theSW.SendBoolean (theEnt->RY()); + + theSW.SendBoolean (theEnt->RZ()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWSphericalPairWithPin::Share (const Handle(StepKinematics_SphericalPairWithPin)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of LowOrderKinematicPair +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithPin.hxx b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithPin.hxx new file mode 100644 index 0000000000..eb398abb53 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithPin.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWSphericalPairWithPin_HeaderFile_ +#define _RWStepKinematics_RWSphericalPairWithPin_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_SphericalPairWithPin)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_SphericalPairWithPin)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_SphericalPairWithPin)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWSphericalPairWithPin_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithPinAndRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithPinAndRange.cxx new file mode 100644 index 0000000000..5a99ab8146 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithPinAndRange.cxx @@ -0,0 +1,255 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_SphericalPairWithPinAndRange)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,16,theArch,"spherical_pair_with_pin_and_range") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of LowOrderKinematicPair + + Standard_Boolean aLowOrderKinematicPair_TX; + theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX); + + Standard_Boolean aLowOrderKinematicPair_TY; + theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY); + + Standard_Boolean aLowOrderKinematicPair_TZ; + theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ); + + Standard_Boolean aLowOrderKinematicPair_RX; + theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX); + + Standard_Boolean aLowOrderKinematicPair_RY; + theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY); + + Standard_Boolean aLowOrderKinematicPair_RZ; + theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ); + + // Own fields of SphericalPairWithPinAndRange + + Standard_Real aLowerLimitYaw; + Standard_Boolean hasLowerLimitYaw = Standard_True; + if ( theData->IsParamDefined (theNum,13) ) { + theData->ReadReal (theNum, 13, "lower_limit_yaw", theArch, aLowerLimitYaw); + } + else { + hasLowerLimitYaw = Standard_False; + aLowerLimitYaw = 0; + } + + Standard_Real aUpperLimitYaw; + Standard_Boolean hasUpperLimitYaw = Standard_True; + if ( theData->IsParamDefined (theNum,14) ) { + theData->ReadReal (theNum, 14, "upper_limit_yaw", theArch, aUpperLimitYaw); + } + else { + hasUpperLimitYaw = Standard_False; + aUpperLimitYaw = 0; + } + + Standard_Real aLowerLimitRoll; + Standard_Boolean hasLowerLimitRoll = Standard_True; + if ( theData->IsParamDefined (theNum,15) ) { + theData->ReadReal (theNum, 15, "lower_limit_roll", theArch, aLowerLimitRoll); + } + else { + hasLowerLimitRoll = Standard_False; + aLowerLimitRoll = 0; + } + + Standard_Real aUpperLimitRoll; + Standard_Boolean hasUpperLimitRoll = Standard_True; + if ( theData->IsParamDefined (theNum,16) ) { + theData->ReadReal (theNum, 16, "upper_limit_roll", theArch, aUpperLimitRoll); + } + else { + hasUpperLimitRoll = Standard_False; + aUpperLimitRoll = 0; + } + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ, + hasLowerLimitYaw, + aLowerLimitYaw, + hasUpperLimitYaw, + aUpperLimitYaw, + hasLowerLimitRoll, + aLowerLimitRoll, + hasUpperLimitRoll, + aUpperLimitRoll); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWSphericalPairWithPinAndRange::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_SphericalPairWithPinAndRange)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of LowOrderKinematicPair + + theSW.SendBoolean (theEnt->TX()); + + theSW.SendBoolean (theEnt->TY()); + + theSW.SendBoolean (theEnt->TZ()); + + theSW.SendBoolean (theEnt->RX()); + + theSW.SendBoolean (theEnt->RY()); + + theSW.SendBoolean (theEnt->RZ()); + + // Own fields of SphericalPairWithPinAndRange + + if ( theEnt->HasLowerLimitYaw() ) { + theSW.Send (theEnt->LowerLimitYaw()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitYaw() ) { + theSW.Send (theEnt->UpperLimitYaw()); + } + else theSW.SendUndef(); + + if ( theEnt->HasLowerLimitRoll() ) { + theSW.Send (theEnt->LowerLimitRoll()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitRoll() ) { + theSW.Send (theEnt->UpperLimitRoll()); + } + else theSW.SendUndef(); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWSphericalPairWithPinAndRange::Share (const Handle(StepKinematics_SphericalPairWithPinAndRange)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of LowOrderKinematicPair + + // Own fields of SphericalPairWithPinAndRange +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithPinAndRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithPinAndRange.hxx new file mode 100644 index 0000000000..8a0e0b4c05 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithPinAndRange.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWSphericalPairWithPinAndRange_HeaderFile_ +#define _RWStepKinematics_RWSphericalPairWithPinAndRange_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_SphericalPairWithPinAndRange)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_SphericalPairWithPinAndRange)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_SphericalPairWithPinAndRange)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWSphericalPairWithPinAndRange_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithRange.cxx new file mode 100644 index 0000000000..edc3148cba --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithRange.cxx @@ -0,0 +1,289 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_SphericalPairWithRange)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,18,theArch,"spherical_pair_with_range") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of LowOrderKinematicPair + + Standard_Boolean aLowOrderKinematicPair_TX; + theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX); + + Standard_Boolean aLowOrderKinematicPair_TY; + theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY); + + Standard_Boolean aLowOrderKinematicPair_TZ; + theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ); + + Standard_Boolean aLowOrderKinematicPair_RX; + theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX); + + Standard_Boolean aLowOrderKinematicPair_RY; + theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY); + + Standard_Boolean aLowOrderKinematicPair_RZ; + theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ); + + // Own fields of SphericalPairWithRange + + Standard_Real aLowerLimitYaw; + Standard_Boolean hasLowerLimitYaw = Standard_True; + if ( theData->IsParamDefined (theNum,13) ) { + theData->ReadReal (theNum, 13, "lower_limit_yaw", theArch, aLowerLimitYaw); + } + else { + hasLowerLimitYaw = Standard_False; + aLowerLimitYaw = 0; + } + + Standard_Real aUpperLimitYaw; + Standard_Boolean hasUpperLimitYaw = Standard_True; + if ( theData->IsParamDefined (theNum,14) ) { + theData->ReadReal (theNum, 14, "upper_limit_yaw", theArch, aUpperLimitYaw); + } + else { + hasUpperLimitYaw = Standard_False; + aUpperLimitYaw = 0; + } + + Standard_Real aLowerLimitPitch; + Standard_Boolean hasLowerLimitPitch = Standard_True; + if ( theData->IsParamDefined (theNum,15) ) { + theData->ReadReal (theNum, 15, "lower_limit_pitch", theArch, aLowerLimitPitch); + } + else { + hasLowerLimitPitch = Standard_False; + aLowerLimitPitch = 0; + } + + Standard_Real aUpperLimitPitch; + Standard_Boolean hasUpperLimitPitch = Standard_True; + if ( theData->IsParamDefined (theNum,16) ) { + theData->ReadReal (theNum, 16, "upper_limit_pitch", theArch, aUpperLimitPitch); + } + else { + hasUpperLimitPitch = Standard_False; + aUpperLimitPitch = 0; + } + + Standard_Real aLowerLimitRoll; + Standard_Boolean hasLowerLimitRoll = Standard_True; + if ( theData->IsParamDefined (theNum,17) ) { + theData->ReadReal (theNum, 17, "lower_limit_roll", theArch, aLowerLimitRoll); + } + else { + hasLowerLimitRoll = Standard_False; + aLowerLimitRoll = 0; + } + + Standard_Real aUpperLimitRoll; + Standard_Boolean hasUpperLimitRoll = Standard_True; + if ( theData->IsParamDefined (theNum,18) ) { + theData->ReadReal (theNum, 18, "upper_limit_roll", theArch, aUpperLimitRoll); + } + else { + hasUpperLimitRoll = Standard_False; + aUpperLimitRoll = 0; + } + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ, + hasLowerLimitYaw, + aLowerLimitYaw, + hasUpperLimitYaw, + aUpperLimitYaw, + hasLowerLimitPitch, + aLowerLimitPitch, + hasUpperLimitPitch, + aUpperLimitPitch, + hasLowerLimitRoll, + aLowerLimitRoll, + hasUpperLimitRoll, + aUpperLimitRoll); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWSphericalPairWithRange::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_SphericalPairWithRange)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of LowOrderKinematicPair + + theSW.SendBoolean (theEnt->TX()); + + theSW.SendBoolean (theEnt->TY()); + + theSW.SendBoolean (theEnt->TZ()); + + theSW.SendBoolean (theEnt->RX()); + + theSW.SendBoolean (theEnt->RY()); + + theSW.SendBoolean (theEnt->RZ()); + + // Own fields of SphericalPairWithRange + + if ( theEnt->HasLowerLimitYaw() ) { + theSW.Send (theEnt->LowerLimitYaw()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitYaw() ) { + theSW.Send (theEnt->UpperLimitYaw()); + } + else theSW.SendUndef(); + + if ( theEnt->HasLowerLimitPitch() ) { + theSW.Send (theEnt->LowerLimitPitch()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitPitch() ) { + theSW.Send (theEnt->UpperLimitPitch()); + } + else theSW.SendUndef(); + + if ( theEnt->HasLowerLimitRoll() ) { + theSW.Send (theEnt->LowerLimitRoll()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitRoll() ) { + theSW.Send (theEnt->UpperLimitRoll()); + } + else theSW.SendUndef(); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWSphericalPairWithRange::Share (const Handle(StepKinematics_SphericalPairWithRange)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of LowOrderKinematicPair + + // Own fields of SphericalPairWithRange +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithRange.hxx new file mode 100644 index 0000000000..f08c617128 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSphericalPairWithRange.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWSphericalPairWithRange_HeaderFile_ +#define _RWStepKinematics_RWSphericalPairWithRange_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_SphericalPairWithRange)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_SphericalPairWithRange)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_SphericalPairWithRange)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWSphericalPairWithRange_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWSurfacePairWithRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWSurfacePairWithRange.cxx new file mode 100644 index 0000000000..f7469aee8e --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSurfacePairWithRange.cxx @@ -0,0 +1,225 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_SurfacePairWithRange)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,13,theArch,"surface_pair_with_range") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of SurfacePair + + Handle(StepGeom_Surface) aSurfacePair_Surface1; + theData->ReadEntity (theNum, 7, "surface_pair.surface1", theArch, STANDARD_TYPE(StepGeom_Surface), aSurfacePair_Surface1); + + Handle(StepGeom_Surface) aSurfacePair_Surface2; + theData->ReadEntity (theNum, 8, "surface_pair.surface2", theArch, STANDARD_TYPE(StepGeom_Surface), aSurfacePair_Surface2); + + Standard_Boolean aSurfacePair_Orientation; + theData->ReadBoolean (theNum, 9, "surface_pair.orientation", theArch, aSurfacePair_Orientation); + + // Own fields of SurfacePairWithRange + + Handle(StepGeom_RectangularTrimmedSurface) aRangeOnSurface1; + theData->ReadEntity (theNum, 10, "range_on_surface1", theArch, STANDARD_TYPE(StepGeom_RectangularTrimmedSurface), aRangeOnSurface1); + + Handle(StepGeom_RectangularTrimmedSurface) aRangeOnSurface2; + theData->ReadEntity (theNum, 11, "range_on_surface2", theArch, STANDARD_TYPE(StepGeom_RectangularTrimmedSurface), aRangeOnSurface2); + + Standard_Real aLowerLimitActualRotation; + Standard_Boolean hasLowerLimitActualRotation = Standard_True; + if ( theData->IsParamDefined (theNum,12) ) { + theData->ReadReal (theNum, 12, "lower_limit_actual_rotation", theArch, aLowerLimitActualRotation); + } + else { + hasLowerLimitActualRotation = Standard_False; + aLowerLimitActualRotation = 0; + } + + Standard_Real aUpperLimitActualRotation; + Standard_Boolean hasUpperLimitActualRotation = Standard_True; + if ( theData->IsParamDefined (theNum,13) ) { + theData->ReadReal (theNum, 13, "upper_limit_actual_rotation", theArch, aUpperLimitActualRotation); + } + else { + hasUpperLimitActualRotation = Standard_False; + aUpperLimitActualRotation = 0; + } + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aSurfacePair_Surface1, + aSurfacePair_Surface2, + aSurfacePair_Orientation, + aRangeOnSurface1, + aRangeOnSurface2, + hasLowerLimitActualRotation, + aLowerLimitActualRotation, + hasUpperLimitActualRotation, + aUpperLimitActualRotation); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWSurfacePairWithRange::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_SurfacePairWithRange)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of SurfacePair + + theSW.Send (theEnt->Surface1()); + + theSW.Send (theEnt->Surface2()); + + theSW.SendBoolean (theEnt->Orientation()); + + // Own fields of SurfacePairWithRange + + theSW.Send (theEnt->RangeOnSurface1()); + + theSW.Send (theEnt->RangeOnSurface2()); + + if ( theEnt->HasLowerLimitActualRotation() ) { + theSW.Send (theEnt->LowerLimitActualRotation()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitActualRotation() ) { + theSW.Send (theEnt->UpperLimitActualRotation()); + } + else theSW.SendUndef(); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWSurfacePairWithRange::Share (const Handle(StepKinematics_SurfacePairWithRange)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of SurfacePair + + iter.AddItem (theEnt->StepKinematics_SurfacePair::Surface1()); + + iter.AddItem (theEnt->StepKinematics_SurfacePair::Surface2()); + + // Own fields of SurfacePairWithRange + + iter.AddItem (theEnt->RangeOnSurface1()); + + iter.AddItem (theEnt->RangeOnSurface2()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWSurfacePairWithRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWSurfacePairWithRange.hxx new file mode 100644 index 0000000000..b423e4b7ef --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWSurfacePairWithRange.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWSurfacePairWithRange_HeaderFile_ +#define _RWStepKinematics_RWSurfacePairWithRange_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_SurfacePairWithRange)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_SurfacePairWithRange)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_SurfacePairWithRange)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWSurfacePairWithRange_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWUnconstrainedPair.cxx b/src/RWStepKinematics/RWStepKinematics_RWUnconstrainedPair.cxx new file mode 100644 index 0000000000..16163a9dbf --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWUnconstrainedPair.cxx @@ -0,0 +1,180 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_UnconstrainedPair)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,12,theArch,"unconstrained_pair") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of LowOrderKinematicPair + + Standard_Boolean aLowOrderKinematicPair_TX; + theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX); + + Standard_Boolean aLowOrderKinematicPair_TY; + theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY); + + Standard_Boolean aLowOrderKinematicPair_TZ; + theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ); + + Standard_Boolean aLowOrderKinematicPair_RX; + theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX); + + Standard_Boolean aLowOrderKinematicPair_RY; + theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY); + + Standard_Boolean aLowOrderKinematicPair_RZ; + theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWUnconstrainedPair::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_UnconstrainedPair)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of LowOrderKinematicPair + + theSW.SendBoolean (theEnt->TX()); + + theSW.SendBoolean (theEnt->TY()); + + theSW.SendBoolean (theEnt->TZ()); + + theSW.SendBoolean (theEnt->RX()); + + theSW.SendBoolean (theEnt->RY()); + + theSW.SendBoolean (theEnt->RZ()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWUnconstrainedPair::Share (const Handle(StepKinematics_UnconstrainedPair)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of LowOrderKinematicPair +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWUnconstrainedPair.hxx b/src/RWStepKinematics/RWStepKinematics_RWUnconstrainedPair.hxx new file mode 100644 index 0000000000..9b262bd9ae --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWUnconstrainedPair.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWUnconstrainedPair_HeaderFile_ +#define _RWStepKinematics_RWUnconstrainedPair_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_UnconstrainedPair)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_UnconstrainedPair)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_UnconstrainedPair)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWUnconstrainedPair_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWUnconstrainedPairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWUnconstrainedPairValue.cxx new file mode 100644 index 0000000000..d5c05409db --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWUnconstrainedPairValue.cxx @@ -0,0 +1,105 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_UnconstrainedPairValue)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,3,theArch,"unconstrained_pair_value") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of PairValue + + Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair; + theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair); + + // Own fields of UnconstrainedPairValue + + Handle(StepGeom_Axis2Placement3d) aActualPlacement; + theData->ReadEntity (theNum, 3, "actual_placement", theArch, STANDARD_TYPE(StepGeom_Axis2Placement3d), aActualPlacement); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aPairValue_AppliesToPair, + aActualPlacement); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWUnconstrainedPairValue::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_UnconstrainedPairValue)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Own fields of PairValue + + theSW.Send (theEnt->AppliesToPair()); + + // Own fields of UnconstrainedPairValue + + theSW.Send (theEnt->ActualPlacement()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWUnconstrainedPairValue::Share (const Handle(StepKinematics_UnconstrainedPairValue)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of PairValue + + iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair()); + + // Own fields of UnconstrainedPairValue + + iter.AddItem (theEnt->ActualPlacement()); +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWUnconstrainedPairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWUnconstrainedPairValue.hxx new file mode 100644 index 0000000000..8f53fb4bf5 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWUnconstrainedPairValue.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWUnconstrainedPairValue_HeaderFile_ +#define _RWStepKinematics_RWUnconstrainedPairValue_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_UnconstrainedPairValue)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_UnconstrainedPairValue)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_UnconstrainedPairValue)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWUnconstrainedPairValue_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWUniversalPair.cxx b/src/RWStepKinematics/RWStepKinematics_RWUniversalPair.cxx new file mode 100644 index 0000000000..9de814daae --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWUniversalPair.cxx @@ -0,0 +1,204 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_UniversalPair)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,13,theArch,"universal_pair") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of LowOrderKinematicPair + + Standard_Boolean aLowOrderKinematicPair_TX; + theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX); + + Standard_Boolean aLowOrderKinematicPair_TY; + theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY); + + Standard_Boolean aLowOrderKinematicPair_TZ; + theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ); + + Standard_Boolean aLowOrderKinematicPair_RX; + theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX); + + Standard_Boolean aLowOrderKinematicPair_RY; + theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY); + + Standard_Boolean aLowOrderKinematicPair_RZ; + theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ); + + // Own fields of UniversalPair + + Standard_Real aInputSkewAngle; + Standard_Boolean hasInputSkewAngle = Standard_True; + if ( theData->IsParamDefined (theNum,13) ) { + theData->ReadReal (theNum, 13, "input_skew_angle", theArch, aInputSkewAngle); + } + else { + hasInputSkewAngle = Standard_False; + aInputSkewAngle = 0; + } + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ, + hasInputSkewAngle, + aInputSkewAngle); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWUniversalPair::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_UniversalPair)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of LowOrderKinematicPair + + theSW.SendBoolean (theEnt->TX()); + + theSW.SendBoolean (theEnt->TY()); + + theSW.SendBoolean (theEnt->TZ()); + + theSW.SendBoolean (theEnt->RX()); + + theSW.SendBoolean (theEnt->RY()); + + theSW.SendBoolean (theEnt->RZ()); + + // Own fields of UniversalPair + + if ( theEnt->HasInputSkewAngle() ) { + theSW.Send (theEnt->InputSkewAngle()); + } + else theSW.SendUndef(); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWUniversalPair::Share (const Handle(StepKinematics_UniversalPair)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of LowOrderKinematicPair + + // Own fields of UniversalPair +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWUniversalPair.hxx b/src/RWStepKinematics/RWStepKinematics_RWUniversalPair.hxx new file mode 100644 index 0000000000..687f3ed934 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWUniversalPair.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWUniversalPair_HeaderFile_ +#define _RWStepKinematics_RWUniversalPair_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_UniversalPair)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_UniversalPair)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_UniversalPair)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWUniversalPair_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWUniversalPairValue.cxx b/src/RWStepKinematics/RWStepKinematics_RWUniversalPairValue.cxx new file mode 100644 index 0000000000..45b86dbed6 --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWUniversalPairValue.cxx @@ -0,0 +1,109 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_UniversalPairValue)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,4,theArch,"universal_pair_value") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of PairValue + + Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair; + theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair); + + // Own fields of UniversalPairValue + + Standard_Real aFirstRotationAngle; + theData->ReadReal (theNum, 3, "first_rotation_angle", theArch, aFirstRotationAngle); + + Standard_Real aSecondRotationAngle; + theData->ReadReal (theNum, 4, "second_rotation_angle", theArch, aSecondRotationAngle); + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aPairValue_AppliesToPair, + aFirstRotationAngle, + aSecondRotationAngle); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWUniversalPairValue::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_UniversalPairValue)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Own fields of PairValue + + theSW.Send (theEnt->AppliesToPair()); + + // Own fields of UniversalPairValue + + theSW.Send (theEnt->FirstRotationAngle()); + + theSW.Send (theEnt->SecondRotationAngle()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWUniversalPairValue::Share (const Handle(StepKinematics_UniversalPairValue)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of PairValue + + iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair()); + + // Own fields of UniversalPairValue +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWUniversalPairValue.hxx b/src/RWStepKinematics/RWStepKinematics_RWUniversalPairValue.hxx new file mode 100644 index 0000000000..d31050498e --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWUniversalPairValue.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWUniversalPairValue_HeaderFile_ +#define _RWStepKinematics_RWUniversalPairValue_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_UniversalPairValue)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_UniversalPairValue)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_UniversalPairValue)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWUniversalPairValue_HeaderFile_ diff --git a/src/RWStepKinematics/RWStepKinematics_RWUniversalPairWithRange.cxx b/src/RWStepKinematics/RWStepKinematics_RWUniversalPairWithRange.cxx new file mode 100644 index 0000000000..511546e68d --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWUniversalPairWithRange.cxx @@ -0,0 +1,278 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theArch, + const Handle(StepKinematics_UniversalPairWithRange)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,17,theArch,"universal_pair_with_range") ) return; + + // Inherited fields of RepresentationItem + + Handle(TCollection_HAsciiString) aRepresentationItem_Name; + theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name); + + // Inherited fields of ItemDefinedTransformation + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name; + theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name); + + Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description; + Standard_Boolean hasItemDefinedTransformation_Description = Standard_True; + if ( theData->IsParamDefined (theNum,3) ) { + theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description); + } + else { + hasItemDefinedTransformation_Description = Standard_False; + aItemDefinedTransformation_Description.Nullify(); + } + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1; + theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1); + + Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2; + theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2); + + // Inherited fields of KinematicPair + + Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint; + theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint); + + // Inherited fields of LowOrderKinematicPair + + Standard_Boolean aLowOrderKinematicPair_TX; + theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX); + + Standard_Boolean aLowOrderKinematicPair_TY; + theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY); + + Standard_Boolean aLowOrderKinematicPair_TZ; + theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ); + + Standard_Boolean aLowOrderKinematicPair_RX; + theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX); + + Standard_Boolean aLowOrderKinematicPair_RY; + theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY); + + Standard_Boolean aLowOrderKinematicPair_RZ; + theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ); + + // Inherited fields of UniversalPair + + Standard_Real aUniversalPair_InputSkewAngle; + Standard_Boolean hasUniversalPair_InputSkewAngle = Standard_True; + if ( theData->IsParamDefined (theNum,13) ) { + theData->ReadReal (theNum, 13, "universal_pair.input_skew_angle", theArch, aUniversalPair_InputSkewAngle); + } + else { + hasUniversalPair_InputSkewAngle = Standard_False; + aUniversalPair_InputSkewAngle = 0; + } + + // Own fields of UniversalPairWithRange + + Standard_Real aLowerLimitFirstRotation; + Standard_Boolean hasLowerLimitFirstRotation = Standard_True; + if ( theData->IsParamDefined (theNum,14) ) { + theData->ReadReal (theNum, 14, "lower_limit_first_rotation", theArch, aLowerLimitFirstRotation); + } + else { + hasLowerLimitFirstRotation = Standard_False; + aLowerLimitFirstRotation = 0; + } + + Standard_Real aUpperLimitFirstRotation; + Standard_Boolean hasUpperLimitFirstRotation = Standard_True; + if ( theData->IsParamDefined (theNum,15) ) { + theData->ReadReal (theNum, 15, "upper_limit_first_rotation", theArch, aUpperLimitFirstRotation); + } + else { + hasUpperLimitFirstRotation = Standard_False; + aUpperLimitFirstRotation = 0; + } + + Standard_Real aLowerLimitSecondRotation; + Standard_Boolean hasLowerLimitSecondRotation = Standard_True; + if ( theData->IsParamDefined (theNum,16) ) { + theData->ReadReal (theNum, 16, "lower_limit_second_rotation", theArch, aLowerLimitSecondRotation); + } + else { + hasLowerLimitSecondRotation = Standard_False; + aLowerLimitSecondRotation = 0; + } + + Standard_Real aUpperLimitSecondRotation; + Standard_Boolean hasUpperLimitSecondRotation = Standard_True; + if ( theData->IsParamDefined (theNum,17) ) { + theData->ReadReal (theNum, 17, "upper_limit_second_rotation", theArch, aUpperLimitSecondRotation); + } + else { + hasUpperLimitSecondRotation = Standard_False; + aUpperLimitSecondRotation = 0; + } + + // Initialize entity + theEnt->Init(aRepresentationItem_Name, + aItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + aItemDefinedTransformation_Description, + aItemDefinedTransformation_TransformItem1, + aItemDefinedTransformation_TransformItem2, + aKinematicPair_Joint, + aLowOrderKinematicPair_TX, + aLowOrderKinematicPair_TY, + aLowOrderKinematicPair_TZ, + aLowOrderKinematicPair_RX, + aLowOrderKinematicPair_RY, + aLowOrderKinematicPair_RZ, + hasUniversalPair_InputSkewAngle, + aUniversalPair_InputSkewAngle, + hasLowerLimitFirstRotation, + aLowerLimitFirstRotation, + hasUpperLimitFirstRotation, + aUpperLimitFirstRotation, + hasLowerLimitSecondRotation, + aLowerLimitSecondRotation, + hasUpperLimitSecondRotation, + aUpperLimitSecondRotation); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= +void RWStepKinematics_RWUniversalPairWithRange::WriteStep (StepData_StepWriter& theSW, + const Handle(StepKinematics_UniversalPairWithRange)& theEnt) const +{ + + // Own fields of RepresentationItem + + theSW.Send (theEnt->Name()); + + // Inherited fields of ItemDefinedTransformation + + theSW.Send (theEnt->ItemDefinedTransformation()->Name()); + + if ( theEnt->ItemDefinedTransformation()->HasDescription() ) { + theSW.Send (theEnt->ItemDefinedTransformation()->Description()); + } + else theSW.SendUndef(); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1()); + + theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Own fields of KinematicPair + + theSW.Send (theEnt->Joint()); + + // Own fields of LowOrderKinematicPair + + theSW.SendBoolean (theEnt->TX()); + + theSW.SendBoolean (theEnt->TY()); + + theSW.SendBoolean (theEnt->TZ()); + + theSW.SendBoolean (theEnt->RX()); + + theSW.SendBoolean (theEnt->RY()); + + theSW.SendBoolean (theEnt->RZ()); + + // Own fields of UniversalPair + + if ( theEnt->HasInputSkewAngle() ) { + theSW.Send (theEnt->InputSkewAngle()); + } + else theSW.SendUndef(); + + // Own fields of UniversalPairWithRange + + if ( theEnt->HasLowerLimitFirstRotation() ) { + theSW.Send (theEnt->LowerLimitFirstRotation()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitFirstRotation() ) { + theSW.Send (theEnt->UpperLimitFirstRotation()); + } + else theSW.SendUndef(); + + if ( theEnt->HasLowerLimitSecondRotation() ) { + theSW.Send (theEnt->LowerLimitSecondRotation()); + } + else theSW.SendUndef(); + + if ( theEnt->HasUpperLimitSecondRotation() ) { + theSW.Send (theEnt->UpperLimitSecondRotation()); + } + else theSW.SendUndef(); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= +void RWStepKinematics_RWUniversalPairWithRange::Share (const Handle(StepKinematics_UniversalPairWithRange)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Inherited fields of RepresentationItem + + // Inherited fields of ItemDefinedTransformation + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1()); + + iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2()); + + // Inherited fields of KinematicPair + + iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint()); + + // Inherited fields of LowOrderKinematicPair + + // Inherited fields of UniversalPair + + // Own fields of UniversalPairWithRange +} diff --git a/src/RWStepKinematics/RWStepKinematics_RWUniversalPairWithRange.hxx b/src/RWStepKinematics/RWStepKinematics_RWUniversalPairWithRange.hxx new file mode 100644 index 0000000000..c4bbbe36df --- /dev/null +++ b/src/RWStepKinematics/RWStepKinematics_RWUniversalPairWithRange.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepKinematics_RWUniversalPairWithRange_HeaderFile_ +#define _RWStepKinematics_RWUniversalPairWithRange_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_UniversalPairWithRange)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_UniversalPairWithRange)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepKinematics_UniversalPairWithRange)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepKinematics_RWUniversalPairWithRange_HeaderFile_ 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..c30de07974 --- /dev/null +++ b/src/RWStepRepr/RWStepRepr_RWRepresentationContextReference.cxx @@ -0,0 +1,79 @@ +// Created on : Sat May 02 12:41:14 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#include +#include +#include +#include +#include + +//======================================================================= +//function : RWStepRepr_RWRepresentationContextReference +//purpose : +//======================================================================= + +RWStepRepr_RWRepresentationContextReference::RWStepRepr_RWRepresentationContextReference() {} + + +//======================================================================= +//function : ReadStep +//purpose : +//======================================================================= + +void RWStepRepr_RWRepresentationContextReference::ReadStep (const Handle(StepData_StepReaderData)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theAch, + const Handle(StepRepr_RepresentationContextReference)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,1,theAch,"representation_context_reference") ) return; + + // Own fields of RepresentationContextReference + + Handle(TCollection_HAsciiString) aContextIdentifier; + theData->ReadString (theNum, 1, "context_identifier", theAch, aContextIdentifier); + + // Initialize entity + theEnt->Init(aContextIdentifier); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= + +void RWStepRepr_RWRepresentationContextReference::WriteStep (StepData_StepWriter& theSW, + const Handle(StepRepr_RepresentationContextReference)& theEnt) const +{ + + // Own fields of RepresentationContextReference + + theSW.Send (theEnt->ContextIdentifier()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= + +void RWStepRepr_RWRepresentationContextReference::Share (const Handle(StepRepr_RepresentationContextReference)& /*theEnt*/, + Interface_EntityIterator& /*iter*/) const +{ + + // Own fields of RepresentationContextReference +} diff --git a/src/RWStepRepr/RWStepRepr_RWRepresentationContextReference.hxx b/src/RWStepRepr/RWStepRepr_RWRepresentationContextReference.hxx new file mode 100644 index 0000000000..5cb1bb4d18 --- /dev/null +++ b/src/RWStepRepr/RWStepRepr_RWRepresentationContextReference.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:14 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepRepr_RWRepresentationContextReference_HeaderFile_ +#define _RWStepRepr_RWRepresentationContextReference_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theAch, const Handle(StepRepr_RepresentationContextReference)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepRepr_RepresentationContextReference)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepRepr_RepresentationContextReference)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepRepr_RWRepresentationContextReference_HeaderFile_ diff --git a/src/RWStepRepr/RWStepRepr_RWRepresentationReference.cxx b/src/RWStepRepr/RWStepRepr_RWRepresentationReference.cxx new file mode 100644 index 0000000000..680db6227d --- /dev/null +++ b/src/RWStepRepr/RWStepRepr_RWRepresentationReference.cxx @@ -0,0 +1,88 @@ +// Created on : Sat May 02 12:41:14 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#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)& theData, + const Standard_Integer theNum, + Handle(Interface_Check)& theAch, + const Handle(StepRepr_RepresentationReference)& theEnt) const +{ + // Check number of parameters + if ( ! theData->CheckNbParams(theNum,2,theAch,"representation_reference") ) return; + + // Own fields of RepresentationReference + + Handle(TCollection_HAsciiString) aId; + theData->ReadString (theNum, 1, "id", theAch, aId); + + Handle(StepRepr_RepresentationContextReference) aContextOfItems; + theData->ReadEntity (theNum, 2, "context_of_items", theAch, STANDARD_TYPE(StepRepr_RepresentationContextReference), aContextOfItems); + + // Initialize entity + theEnt->Init(aId, + aContextOfItems); +} + +//======================================================================= +//function : WriteStep +//purpose : +//======================================================================= + +void RWStepRepr_RWRepresentationReference::WriteStep (StepData_StepWriter& SW, + const Handle(StepRepr_RepresentationReference)& theEnt) const +{ + + // Own fields of RepresentationReference + + SW.Send (theEnt->Id()); + + SW.Send (theEnt->ContextOfItems()); +} + +//======================================================================= +//function : Share +//purpose : +//======================================================================= + +void RWStepRepr_RWRepresentationReference::Share (const Handle(StepRepr_RepresentationReference)& theEnt, + Interface_EntityIterator& iter) const +{ + + // Own fields of RepresentationReference + + iter.AddItem (theEnt->ContextOfItems()); +} diff --git a/src/RWStepRepr/RWStepRepr_RWRepresentationReference.hxx b/src/RWStepRepr/RWStepRepr_RWRepresentationReference.hxx new file mode 100644 index 0000000000..633b92dd15 --- /dev/null +++ b/src/RWStepRepr/RWStepRepr_RWRepresentationReference.hxx @@ -0,0 +1,46 @@ +// Created on : Sat May 02 12:41:14 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _RWStepRepr_RWRepresentationReference_HeaderFile_ +#define _RWStepRepr_RWRepresentationReference_HeaderFile_ + +#include +#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)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theAch, const Handle(StepRepr_RepresentationReference)& theEnt) const; + + Standard_EXPORT void WriteStep(StepData_StepWriter& SW, const Handle(StepRepr_RepresentationReference)& theEnt) const; + + Standard_EXPORT void Share(const Handle(StepRepr_RepresentationReference)& theEnt, Interface_EntityIterator& iter) const; + +}; +#endif // _RWStepRepr_RWRepresentationReference_HeaderFile_ diff --git a/src/STEPCAFControl/STEPCAFControl_Reader.cxx b/src/STEPCAFControl/STEPCAFControl_Reader.cxx index a0b4fbb0bb..93a952e404 100644 --- a/src/STEPCAFControl/STEPCAFControl_Reader.cxx +++ b/src/STEPCAFControl/STEPCAFControl_Reader.cxx @@ -374,6 +374,7 @@ void STEPCAFControl_Reader::Init(const Handle(XSControl_WorkSession)& WS, // necessary only in Writer, to set good actor: WS->SelectNorm ( "STEP" ); myReader.SetWS(WS, scratch); myFiles.Clear(); + myMap.Clear(); } //======================================================================= @@ -724,26 +725,25 @@ Standard_Boolean STEPCAFControl_Reader::Transfer (STEPControl_Reader &reader, // and insert them to the document Handle(XCAFDoc_ShapeTool) STool = XCAFDoc_DocumentTool::ShapeTool(doc->Main()); if (STool.IsNull()) return Standard_False; - XCAFDoc_DataMapOfShapeLabel map; if (asOne) - Lseq.Append(AddShape(reader.OneShape(), STool, NewShapesMap, ShapePDMap, PDFileMap, map)); + Lseq.Append(AddShape(reader.OneShape(), STool, NewShapesMap, ShapePDMap, PDFileMap)); else { for (i = 1; i <= num; i++) { - Lseq.Append(AddShape(reader.Shape(i), STool, NewShapesMap, ShapePDMap, PDFileMap, map)); + Lseq.Append(AddShape(reader.Shape(i), STool, NewShapesMap, ShapePDMap, PDFileMap)); } } // read colors if (GetColorMode()) - ReadColors(reader.WS(), doc, map); + ReadColors(reader.WS(), doc); // read names if (GetNameMode()) - ReadNames(reader.WS(), doc, PDFileMap, map); + ReadNames(reader.WS(), doc, PDFileMap); // read validation props if (GetPropsMode()) - ReadValProps(reader.WS(), doc, PDFileMap, map); + ReadValProps(reader.WS(), doc, PDFileMap); // read layers if (GetLayerMode()) @@ -751,7 +751,7 @@ Standard_Boolean STEPCAFControl_Reader::Transfer (STEPControl_Reader &reader, // read SHUO entities from STEP model if (GetSHUOMode()) - ReadSHUOs(reader.WS(), doc, PDFileMap, map); + ReadSHUOs(reader.WS(), doc, PDFileMap); // read GDT entities from STEP model if (GetGDTMode()) @@ -767,7 +767,7 @@ Standard_Boolean STEPCAFControl_Reader::Transfer (STEPControl_Reader &reader, // Expand resulting CAF structure for sub-shapes (optionally with their // names) if requested - ExpandSubShapes(STool, map, ShapePDMap); + ExpandSubShapes(STool, ShapePDMap); // Update assembly compounds STool->UpdateAssemblies(); @@ -783,12 +783,11 @@ TDF_Label STEPCAFControl_Reader::AddShape(const TopoDS_Shape &S, const Handle(XCAFDoc_ShapeTool) &STool, const TopTools_MapOfShape &NewShapesMap, const STEPCAFControl_DataMapOfShapePD &ShapePDMap, - const STEPCAFControl_DataMapOfPDExternFile &PDFileMap, - XCAFDoc_DataMapOfShapeLabel &ShapeLabelMap) const + const STEPCAFControl_DataMapOfPDExternFile &PDFileMap) { // if shape has already been mapped, just return corresponding label - if (ShapeLabelMap.IsBound(S)) { - return ShapeLabelMap.Find(S); + if (myMap.IsBound(S)) { + return myMap.Find(S); } // if shape is located, create instance @@ -796,16 +795,16 @@ TDF_Label STEPCAFControl_Reader::AddShape(const TopoDS_Shape &S, TopoDS_Shape S0 = S; TopLoc_Location loc; S0.Location(loc); - AddShape(S0, STool, NewShapesMap, ShapePDMap, PDFileMap, ShapeLabelMap); + AddShape(S0, STool, NewShapesMap, ShapePDMap, PDFileMap); TDF_Label L = STool->AddShape(S, Standard_False); // should create reference - ShapeLabelMap.Bind(S, L); + myMap.Bind(S, L); return L; } // if shape is not compound, simple add it if (S.ShapeType() != TopAbs_COMPOUND) { TDF_Label L = STool->AddShape(S, Standard_False); - ShapeLabelMap.Bind(S, L); + myMap.Bind(S, L); return L; } @@ -833,7 +832,7 @@ TDF_Label STEPCAFControl_Reader::AddShape(const TopoDS_Shape &S, if (!EF->GetLabel().IsNull()) { // but if components >0, ignore extern ref! if (nbComponents <= 0) { - ShapeLabelMap.Bind(S, EF->GetLabel()); + myMap.Bind(S, EF->GetLabel()); STool->SetExternRefs(EF->GetLabel(), SHAS); return EF->GetLabel(); } @@ -851,7 +850,7 @@ TDF_Label STEPCAFControl_Reader::AddShape(const TopoDS_Shape &S, if (!isAssembly) { TDF_Label L = STool->AddShape(S, Standard_False); if (SHAS.Length() > 0) STool->SetExternRefs(L, SHAS); - ShapeLabelMap.Bind(S, L); + myMap.Bind(S, L); return L; } @@ -862,16 +861,16 @@ TDF_Label STEPCAFControl_Reader::AddShape(const TopoDS_Shape &S, TopoDS_Shape Sub0 = it.Value(); TopLoc_Location loc; Sub0.Location(loc); - TDF_Label subL = AddShape(Sub0, STool, NewShapesMap, ShapePDMap, PDFileMap, ShapeLabelMap); + TDF_Label subL = AddShape(Sub0, STool, NewShapesMap, ShapePDMap, PDFileMap); if (!subL.IsNull()) { TDF_Label instL = STool->AddComponent(L, subL, it.Value().Location()); - if (!ShapeLabelMap.IsBound(it.Value())) { - ShapeLabelMap.Bind(it.Value(), instL); + if (!myMap.IsBound(it.Value())) { + myMap.Bind(it.Value(), instL); } } } if (SHAS.Length() > 0) STool->SetExternRefs(L, SHAS); - ShapeLabelMap.Bind(S, L); + myMap.Bind(S, L); //STool->SetShape ( L, S ); // it is necessary for assemblies OCC1747 // commemted by skl for OCC2941 return L; @@ -991,8 +990,7 @@ static void propagateColorToParts(const Handle(XCAFDoc_ShapeTool)& theSTool, //======================================================================= Standard_Boolean STEPCAFControl_Reader::ReadColors(const Handle(XSControl_WorkSession) &WS, - Handle(TDocStd_Document)& Doc, - const XCAFDoc_DataMapOfShapeLabel &ShapeLabelMap) const + Handle(TDocStd_Document)& Doc) const { STEPConstruct_Styles Styles(WS); if (!Styles.LoadStyles()) { @@ -1086,7 +1084,7 @@ Standard_Boolean STEPCAFControl_Reader::ReadColors(const Handle(XSControl_WorkSe TopoDS_Shape aSh; // PTV 10.02.2003 to find component of assembly CORRECTLY STEPConstruct_Tool Tool(WS); - TDF_Label aShLab = FindInstance(NAUO, CTool->ShapeTool(), Tool, ShapeLabelMap); + TDF_Label aShLab = FindInstance(NAUO, CTool->ShapeTool(), Tool, myMap); aSh = CTool->ShapeTool()->GetShape(aShLab); if (!aSh.IsNull()) { S = aSh; @@ -1241,8 +1239,7 @@ TDF_Label STEPCAFControl_Reader::FindInstance(const Handle(StepRepr_NextAssembly Standard_Boolean STEPCAFControl_Reader::ReadNames(const Handle(XSControl_WorkSession) &WS, Handle(TDocStd_Document)& Doc, - const STEPCAFControl_DataMapOfPDExternFile &PDFileMap, - const XCAFDoc_DataMapOfShapeLabel &ShapeLabelMap) const + const STEPCAFControl_DataMapOfPDExternFile &PDFileMap) const { // get starting data const Handle(Interface_InterfaceModel) &Model = WS->Model(); @@ -1282,7 +1279,7 @@ Standard_Boolean STEPCAFControl_Reader::ReadNames(const Handle(XSControl_WorkSes else name = new TCollection_HAsciiString; } // find proper label - L = FindInstance(NAUO, STool, Tool, ShapeLabelMap); + L = FindInstance(NAUO, STool, Tool, myMap); if (L.IsNull()) continue; TCollection_ExtendedString str = convertName (name->String()); @@ -1304,7 +1301,7 @@ Standard_Boolean STEPCAFControl_Reader::ReadNames(const Handle(XSControl_WorkSes name = Prod->Id(); else name = new TCollection_HAsciiString; - L = GetLabelFromPD(PD, STool, TP, PDFileMap, ShapeLabelMap); + L = GetLabelFromPD(PD, STool, TP, PDFileMap, myMap); if (L.IsNull()) continue; TCollection_ExtendedString str = convertName (name->String()); TDataStd_Name::Set(L, str); @@ -1352,8 +1349,7 @@ static TDF_Label GetLabelFromPD(const Handle(StepBasic_ProductDefinition) &PD, Standard_Boolean STEPCAFControl_Reader::ReadValProps(const Handle(XSControl_WorkSession) &WS, Handle(TDocStd_Document)& Doc, - const STEPCAFControl_DataMapOfPDExternFile &PDFileMap, - const XCAFDoc_DataMapOfShapeLabel &ShapeLabelMap) const + const STEPCAFControl_DataMapOfPDExternFile &PDFileMap) const { // get starting data const Handle(XSControl_TransferReader) &TR = WS->TransferReader(); @@ -1393,7 +1389,7 @@ Standard_Boolean STEPCAFControl_Reader::ReadValProps(const Handle(XSControl_Work NAUO = Handle(StepRepr_NextAssemblyUsageOccurrence)::DownCast(subs1.Value()); } if (!NAUO.IsNull()) { - L = FindInstance(NAUO, STool, WS, ShapeLabelMap); + L = FindInstance(NAUO, STool, WS, myMap); if (L.IsNull()) continue; } else { @@ -1405,7 +1401,7 @@ Standard_Boolean STEPCAFControl_Reader::ReadValProps(const Handle(XSControl_Work ProdDef = Handle(StepBasic_ProductDefinition)::DownCast(subsPDS.Value()); } if (ProdDef.IsNull()) continue; - L = GetLabelFromPD(ProdDef, STool, Props, PDFileMap, ShapeLabelMap); + L = GetLabelFromPD(ProdDef, STool, Props, PDFileMap, myMap); } } @@ -1450,8 +1446,8 @@ Standard_Boolean STEPCAFControl_Reader::ReadValProps(const Handle(XSControl_Work TopoDS_Shape S; S = TransferBRep::ShapeResult(TP, binder); if (S.IsNull()) continue; - if (ShapeLabelMap.IsBound(S)) - L = ShapeLabelMap.Find(S); + if (myMap.IsBound(S)) + L = myMap.Find(S); if (L.IsNull()) STool->Search(S, L, Standard_True, Standard_True, Standard_True); } @@ -1656,8 +1652,7 @@ static TDF_Label setSHUOintoDoc(const Handle(XSControl_WorkSession) &WS, Standard_Boolean STEPCAFControl_Reader::ReadSHUOs(const Handle(XSControl_WorkSession) &WS, Handle(TDocStd_Document)& Doc, - const STEPCAFControl_DataMapOfPDExternFile &PDFileMap, - const XCAFDoc_DataMapOfShapeLabel &ShapeLabelMap) const + const STEPCAFControl_DataMapOfPDExternFile &PDFileMap) const { // the big part code duplication from ReadColors. // It is possible to share this code functionality, just to decide how ??? @@ -1724,7 +1719,7 @@ Standard_Boolean STEPCAFControl_Reader::ReadSHUOs(const Handle(XSControl_WorkSes continue; // set the SHUO structure to the document - TDF_Label aLabelForStyle = setSHUOintoDoc(WS, SHUO, STool, PDFileMap, ShapeLabelMap); + TDF_Label aLabelForStyle = setSHUOintoDoc(WS, SHUO, STool, PDFileMap, myMap); if (aLabelForStyle.IsNull()) { #ifdef OCCT_DEBUG std::cout << "Warning: " << __FILE__ << ": coudnot create SHUO structure in the document" << std::endl; @@ -4560,7 +4555,6 @@ void collectRepresentationItems(const Interface_Graph& theGraph, //======================================================================= void STEPCAFControl_Reader::ExpandSubShapes(const Handle(XCAFDoc_ShapeTool)& ShapeTool, - const XCAFDoc_DataMapOfShapeLabel& ShapeLabelMap, const STEPCAFControl_DataMapOfShapePD& ShapePDMap) const { const Handle(Transfer_TransientProcess)& TP = Reader().WS()->TransferReader()->TransientProcess(); @@ -4610,10 +4604,10 @@ void STEPCAFControl_Reader::ExpandSubShapes(const Handle(XCAFDoc_ShapeTool)& Sha if (aReprItems.Length() == 0) continue; - if (!ShapeLabelMap.IsBound(aRootShape)) + if (!myMap.IsBound(aRootShape)) continue; - TDF_Label aRootLab = ShapeLabelMap.Find(aRootShape); + TDF_Label aRootLab = myMap.Find(aRootShape); // Do not add subshapes to assembly, // they will be processed with corresponding Shape_Product_Definition of necessary part. if (ShapeTool->IsAssembly(aRootLab)) diff --git a/src/STEPCAFControl/STEPCAFControl_Reader.hxx b/src/STEPCAFControl/STEPCAFControl_Reader.hxx index def983cbdb..355acdd57f 100644 --- a/src/STEPCAFControl/STEPCAFControl_Reader.hxx +++ b/src/STEPCAFControl/STEPCAFControl_Reader.hxx @@ -172,8 +172,7 @@ public: //! Get View mode Standard_EXPORT Standard_Boolean GetViewMode() const; - - + const XCAFDoc_DataMapOfShapeLabel& GetShapeLabelMap() const { return myMap; } protected: @@ -195,7 +194,7 @@ protected: //! Depending on a case, this shape can be added as one, or //! as assembly, or (in case if it is associated with external //! reference) taken as that referred shape - Standard_EXPORT TDF_Label AddShape (const TopoDS_Shape& S, const Handle(XCAFDoc_ShapeTool)& STool, const TopTools_MapOfShape& NewShapesMap, const STEPCAFControl_DataMapOfShapePD& ShapePDMap, const STEPCAFControl_DataMapOfPDExternFile& PDFileMap, XCAFDoc_DataMapOfShapeLabel& ShapeLabelMap) const; + Standard_EXPORT TDF_Label AddShape (const TopoDS_Shape& S, const Handle(XCAFDoc_ShapeTool)& STool, const TopTools_MapOfShape& NewShapesMap, const STEPCAFControl_DataMapOfShapePD& ShapePDMap, const STEPCAFControl_DataMapOfPDExternFile& PDFileMap); //! Reads (or if returns already read) extern file with //! given name @@ -208,17 +207,16 @@ protected: //! corresponding color assignments in the DECAF document Standard_EXPORT Standard_Boolean ReadColors (const Handle(XSControl_WorkSession)& WS, - Handle(TDocStd_Document)& doc, - const XCAFDoc_DataMapOfShapeLabel& ShapeLabelMap) const; + Handle(TDocStd_Document)& doc) const; //! Reads names of parts defined in the STEP model and //! assigns them to corresponding labels in the DECAF document - Standard_EXPORT Standard_Boolean ReadNames (const Handle(XSControl_WorkSession)& WS, Handle(TDocStd_Document)& doc, const STEPCAFControl_DataMapOfPDExternFile& PDFileMap, const XCAFDoc_DataMapOfShapeLabel& ShapeLabelMap) const; + Standard_EXPORT Standard_Boolean ReadNames (const Handle(XSControl_WorkSession)& WS, Handle(TDocStd_Document)& doc, const STEPCAFControl_DataMapOfPDExternFile& PDFileMap) const; //! Reads validation properties assigned to shapes in the STEP //! model and assigns them to corresponding labels in the DECAF //! document - Standard_EXPORT Standard_Boolean ReadValProps (const Handle(XSControl_WorkSession)& WS, Handle(TDocStd_Document)& doc, const STEPCAFControl_DataMapOfPDExternFile& PDFileMap, const XCAFDoc_DataMapOfShapeLabel& ShapeLabelMap) const; + Standard_EXPORT Standard_Boolean ReadValProps (const Handle(XSControl_WorkSession)& WS, Handle(TDocStd_Document)& doc, const STEPCAFControl_DataMapOfPDExternFile& PDFileMap) const; //! Reads layers of parts defined in the STEP model and //! set reference between shape and layers in the DECAF document @@ -226,7 +224,7 @@ protected: //! Reads SHUO for instances defined in the STEP model and //! set reference between shape instances from different assemblyes - Standard_EXPORT Standard_Boolean ReadSHUOs (const Handle(XSControl_WorkSession)& WS, Handle(TDocStd_Document)& doc, const STEPCAFControl_DataMapOfPDExternFile& PDFileMap, const XCAFDoc_DataMapOfShapeLabel& ShapeLabelMap) const; + Standard_EXPORT Standard_Boolean ReadSHUOs (const Handle(XSControl_WorkSession)& WS, Handle(TDocStd_Document)& doc, const STEPCAFControl_DataMapOfPDExternFile& PDFileMap) const; //! Reads D> for instances defined in the STEP model and //! set reference between shape instances from different assemblyes @@ -248,7 +246,7 @@ protected: //! expands their correspondent Labels in XDE Document so that //! to have a dedicated sub-Label for each sub-shape coming //! with associated name in its STEP Representation Item. - Standard_EXPORT void ExpandSubShapes (const Handle(XCAFDoc_ShapeTool)& theShapeTool, const XCAFDoc_DataMapOfShapeLabel& theShapeLabelMap, const STEPCAFControl_DataMapOfShapePD& theShapePDMap) const; + Standard_EXPORT void ExpandSubShapes (const Handle(XCAFDoc_ShapeTool)& theShapeTool, const STEPCAFControl_DataMapOfShapePD& theShapePDMap) const; //! Expands the topological structure of Manifold Solid BRep //! STEP entity to OCAF sub-tree. Entities having no names @@ -299,6 +297,7 @@ private: STEPControl_Reader myReader; NCollection_DataMap myFiles; + XCAFDoc_DataMapOfShapeLabel myMap; Standard_Boolean myColorMode; Standard_Boolean myNameMode; Standard_Boolean myLayerMode; diff --git a/src/StepAP214/StepAP214_Protocol.cxx b/src/StepAP214/StepAP214_Protocol.cxx index 00da5908ca..7d69f8e42b 100644 --- a/src/StepAP214/StepAP214_Protocol.cxx +++ b/src/StepAP214/StepAP214_Protocol.cxx @@ -750,13 +750,92 @@ static Standard_CString schemaAP242DIS = "AP242_MANAGED_MODEL_BASED_3D_ENGINEERI #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 static int THE_StepAP214_Protocol_init = 0; -static Interface_DataMapOfTransientInteger types(800); +static Interface_DataMapOfTransientInteger types(803); //======================================================================= //function : StepAP214_Protocol @@ -1468,6 +1547,85 @@ StepAP214_Protocol::StepAP214_Protocol () types.Bind (STANDARD_TYPE(StepVisual_SurfaceStyleReflectanceAmbient), 721); types.Bind (STANDARD_TYPE(StepVisual_SurfaceStyleRendering), 722); types.Bind (STANDARD_TYPE(StepVisual_SurfaceStyleRenderingWithProperties), 723); + + // Added for kinematics implementation + types.Bind(STANDARD_TYPE(StepRepr_RepresentationContextReference), 724); + types.Bind(STANDARD_TYPE(StepRepr_RepresentationReference), 725); + types.Bind(STANDARD_TYPE(StepGeom_SuParameters), 726); + types.Bind(STANDARD_TYPE(StepKinematics_RotationAboutDirection), 727); + types.Bind(STANDARD_TYPE(StepKinematics_KinematicJoint), 728); + types.Bind(STANDARD_TYPE(StepKinematics_ActuatedKinematicPair), 729); + types.Bind(STANDARD_TYPE(StepKinematics_ContextDependentKinematicLinkRepresentation), 730); + types.Bind(STANDARD_TYPE(StepKinematics_CylindricalPair), 731); + types.Bind(STANDARD_TYPE(StepKinematics_CylindricalPairValue), 732); + types.Bind(STANDARD_TYPE(StepKinematics_CylindricalPairWithRange), 733); + types.Bind(STANDARD_TYPE(StepKinematics_FullyConstrainedPair), 734); + types.Bind(STANDARD_TYPE(StepKinematics_GearPair), 735); + types.Bind(STANDARD_TYPE(StepKinematics_GearPairValue), 736); + types.Bind(STANDARD_TYPE(StepKinematics_GearPairWithRange), 737); + types.Bind(STANDARD_TYPE(StepKinematics_HomokineticPair), 738); + types.Bind(STANDARD_TYPE(StepKinematics_KinematicLink), 739); + types.Bind(STANDARD_TYPE(StepKinematics_KinematicLinkRepresentationAssociation), 740); + types.Bind(STANDARD_TYPE(StepKinematics_KinematicPropertyMechanismRepresentation), 741); + types.Bind(STANDARD_TYPE(StepKinematics_KinematicTopologyStructure), 742); + types.Bind(STANDARD_TYPE(StepKinematics_LowOrderKinematicPair), 743); + types.Bind(STANDARD_TYPE(StepKinematics_LowOrderKinematicPairValue), 744); + types.Bind(STANDARD_TYPE(StepKinematics_LowOrderKinematicPairWithRange), 745); + types.Bind(STANDARD_TYPE(StepKinematics_MechanismRepresentation), 746); + types.Bind(STANDARD_TYPE(StepKinematics_OrientedJoint), 747); + types.Bind(STANDARD_TYPE(StepKinematics_PlanarCurvePair), 748); + types.Bind(STANDARD_TYPE(StepKinematics_PlanarCurvePairRange), 749); + types.Bind(STANDARD_TYPE(StepKinematics_PlanarPair), 750); + types.Bind(STANDARD_TYPE(StepKinematics_PlanarPairValue), 751); + types.Bind(STANDARD_TYPE(StepKinematics_PlanarPairWithRange), 752); + types.Bind(STANDARD_TYPE(StepKinematics_PointOnPlanarCurvePair), 753); + types.Bind(STANDARD_TYPE(StepKinematics_PointOnPlanarCurvePairValue), 754); + types.Bind(STANDARD_TYPE(StepKinematics_PointOnPlanarCurvePairWithRange), 755); + types.Bind(STANDARD_TYPE(StepKinematics_PointOnSurfacePair), 756); + types.Bind(STANDARD_TYPE(StepKinematics_PointOnSurfacePairValue), 757); + types.Bind(STANDARD_TYPE(StepKinematics_PointOnSurfacePairWithRange), 758); + types.Bind(STANDARD_TYPE(StepKinematics_PrismaticPair), 759); + types.Bind(STANDARD_TYPE(StepKinematics_PrismaticPairValue), 760); + types.Bind(STANDARD_TYPE(StepKinematics_PrismaticPairWithRange), 761); + types.Bind(STANDARD_TYPE(StepKinematics_ProductDefinitionKinematics), 762); + types.Bind(STANDARD_TYPE(StepKinematics_ProductDefinitionRelationshipKinematics), 763); + types.Bind(STANDARD_TYPE(StepKinematics_RackAndPinionPair), 764); + types.Bind(STANDARD_TYPE(StepKinematics_RackAndPinionPairValue), 765); + types.Bind(STANDARD_TYPE(StepKinematics_RackAndPinionPairWithRange), 766); + types.Bind(STANDARD_TYPE(StepKinematics_RevolutePair), 767); + types.Bind(STANDARD_TYPE(StepKinematics_RevolutePairValue), 768); + types.Bind(STANDARD_TYPE(StepKinematics_RevolutePairWithRange), 769); + types.Bind(STANDARD_TYPE(StepKinematics_RollingCurvePair), 770); + types.Bind(STANDARD_TYPE(StepKinematics_RollingCurvePairValue), 771); + types.Bind(STANDARD_TYPE(StepKinematics_RollingSurfacePair), 772); + types.Bind(STANDARD_TYPE(StepKinematics_RollingSurfacePairValue), 773); + types.Bind(STANDARD_TYPE(StepKinematics_ScrewPair), 774); + types.Bind(STANDARD_TYPE(StepKinematics_ScrewPairValue), 775); + types.Bind(STANDARD_TYPE(StepKinematics_ScrewPairWithRange), 776); + types.Bind(STANDARD_TYPE(StepKinematics_SlidingCurvePair), 777); + types.Bind(STANDARD_TYPE(StepKinematics_SlidingCurvePairValue), 778); + types.Bind(STANDARD_TYPE(StepKinematics_SlidingSurfacePair), 779); + types.Bind(STANDARD_TYPE(StepKinematics_SlidingSurfacePairValue), 780); + types.Bind(STANDARD_TYPE(StepKinematics_SphericalPair), 781); + types.Bind(STANDARD_TYPE(StepKinematics_SphericalPairValue), 782); + types.Bind(STANDARD_TYPE(StepKinematics_SphericalPairWithPin), 783); + types.Bind(STANDARD_TYPE(StepKinematics_SphericalPairWithPinAndRange), 784); + types.Bind(STANDARD_TYPE(StepKinematics_SphericalPairWithRange), 785); + types.Bind(STANDARD_TYPE(StepKinematics_SurfacePairWithRange), 786); + types.Bind(STANDARD_TYPE(StepKinematics_UnconstrainedPair), 787); + types.Bind(STANDARD_TYPE(StepKinematics_UnconstrainedPairValue), 788); + types.Bind(STANDARD_TYPE(StepKinematics_UniversalPair), 789); + types.Bind(STANDARD_TYPE(StepKinematics_UniversalPairValue), 790); + types.Bind(STANDARD_TYPE(StepKinematics_UniversalPairWithRange), 791); + types.Bind(STANDARD_TYPE(StepKinematics_PairRepresentationRelationship), 792); + types.Bind(STANDARD_TYPE(StepKinematics_RigidLinkRepresentation), 793); + types.Bind(STANDARD_TYPE(StepKinematics_KinematicTopologyDirectedStructure), 794); + types.Bind(STANDARD_TYPE(StepKinematics_KinematicTopologyNetworkStructure), 795); + types.Bind(STANDARD_TYPE(StepKinematics_LinearFlexibleAndPinionPair), 796); + types.Bind(STANDARD_TYPE(StepKinematics_LinearFlexibleAndPlanarCurvePair), 797); + types.Bind(STANDARD_TYPE(StepKinematics_LinearFlexibleLinkRepresentation), 798); + types.Bind(STANDARD_TYPE(StepKinematics_ActuatedKinPairAndOrderKinPair), 800); + types.Bind(STANDARD_TYPE(StepKinematics_MechanismStateRepresentation), 801); } diff --git a/src/StepGeom/FILES b/src/StepGeom/FILES index 600f2c225e..2f6c00435c 100644 --- a/src/StepGeom/FILES +++ b/src/StepGeom/FILES @@ -162,6 +162,8 @@ StepGeom_SeamCurve.cxx StepGeom_SeamCurve.hxx StepGeom_SphericalSurface.cxx StepGeom_SphericalSurface.hxx +StepGeom_SuParameters.cxx +StepGeom_SuParameters.hxx StepGeom_Surface.cxx StepGeom_Surface.hxx StepGeom_SurfaceBoundary.cxx diff --git a/src/StepGeom/StepGeom_SuParameters.cxx b/src/StepGeom/StepGeom_SuParameters.cxx new file mode 100644 index 0000000000..20c2ce38b8 --- /dev/null +++ b/src/StepGeom/StepGeom_SuParameters.cxx @@ -0,0 +1,176 @@ +// Created on : Sat May 02 12:41:14 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepGeom_SuParameters, StepGeom_GeometricRepresentationItem) + +//======================================================================= +//function : StepGeom_SuParameters +//purpose : +//======================================================================= + +StepGeom_SuParameters::StepGeom_SuParameters () +{ +} + +//======================================================================= +//function : Init +//purpose : +//======================================================================= + +void StepGeom_SuParameters::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Standard_Real theA, + const Standard_Real theAlpha, + const Standard_Real theB, + const Standard_Real theBeta, + const Standard_Real theC, + const Standard_Real theGamma) +{ + StepGeom_GeometricRepresentationItem::Init(theRepresentationItem_Name); + + myA = theA; + + myAlpha = theAlpha; + + myB = theB; + + myBeta = theBeta; + + myC = theC; + + myGamma = theGamma; +} + +//======================================================================= +//function : A +//purpose : +//======================================================================= + +Standard_Real StepGeom_SuParameters::A () const +{ + return myA; +} + +//======================================================================= +//function : SetA +//purpose : +//======================================================================= + +void StepGeom_SuParameters::SetA (const Standard_Real theA) +{ + myA = theA; +} + +//======================================================================= +//function : Alpha +//purpose : +//======================================================================= + +Standard_Real StepGeom_SuParameters::Alpha () const +{ + return myAlpha; +} + +//======================================================================= +//function : SetAlpha +//purpose : +//======================================================================= + +void StepGeom_SuParameters::SetAlpha (const Standard_Real theAlpha) +{ + myAlpha = theAlpha; +} + +//======================================================================= +//function : B +//purpose : +//======================================================================= + +Standard_Real StepGeom_SuParameters::B () const +{ + return myB; +} + +//======================================================================= +//function : SetB +//purpose : +//======================================================================= + +void StepGeom_SuParameters::SetB (const Standard_Real theB) +{ + myB = theB; +} + +//======================================================================= +//function : Beta +//purpose : +//======================================================================= + +Standard_Real StepGeom_SuParameters::Beta () const +{ + return myBeta; +} + +//======================================================================= +//function : SetBeta +//purpose : +//======================================================================= + +void StepGeom_SuParameters::SetBeta (const Standard_Real theBeta) +{ + myBeta = theBeta; +} + +//======================================================================= +//function : C +//purpose : +//======================================================================= + +Standard_Real StepGeom_SuParameters::C () const +{ + return myC; +} + +//======================================================================= +//function : SetC +//purpose : +//======================================================================= + +void StepGeom_SuParameters::SetC (const Standard_Real theC) +{ + myC = theC; +} + +//======================================================================= +//function : Gamma +//purpose : +//======================================================================= + +Standard_Real StepGeom_SuParameters::Gamma () const +{ + return myGamma; +} + +//======================================================================= +//function : SetGamma +//purpose : +//======================================================================= + +void StepGeom_SuParameters::SetGamma (const Standard_Real theGamma) +{ + myGamma = theGamma; +} diff --git a/src/StepGeom/StepGeom_SuParameters.hxx b/src/StepGeom/StepGeom_SuParameters.hxx new file mode 100644 index 0000000000..1a47dbf9e8 --- /dev/null +++ b/src/StepGeom/StepGeom_SuParameters.hxx @@ -0,0 +1,86 @@ +// Created on : Sat May 02 12:41:14 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepGeom_SuParameters_HeaderFile_ +#define _StepGeom_SuParameters_HeaderFile_ + +#include +#include +#include + +#include + +DEFINE_STANDARD_HANDLE(StepGeom_SuParameters, StepGeom_GeometricRepresentationItem) + +//! Representation of STEP entity SuParameters +class StepGeom_SuParameters : public StepGeom_GeometricRepresentationItem +{ +public : + + //! default constructor + Standard_EXPORT StepGeom_SuParameters(); + + //! Initialize all fields (own and inherited) + Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Standard_Real theA, + const Standard_Real theAlpha, + const Standard_Real theB, + const Standard_Real theBeta, + const Standard_Real theC, + const Standard_Real theGamma); + + //! Returns field A + Standard_EXPORT Standard_Real A() const; + //! Sets field A + Standard_EXPORT void SetA (const Standard_Real theA); + + //! Returns field Alpha + Standard_EXPORT Standard_Real Alpha() const; + //! Sets field Alpha + Standard_EXPORT void SetAlpha (const Standard_Real theAlpha); + + //! Returns field B + Standard_EXPORT Standard_Real B() const; + //! Sets field B + Standard_EXPORT void SetB (const Standard_Real theB); + + //! Returns field Beta + Standard_EXPORT Standard_Real Beta() const; + //! Sets field Beta + Standard_EXPORT void SetBeta (const Standard_Real theBeta); + + //! Returns field C + Standard_EXPORT Standard_Real C() const; + //! Sets field C + Standard_EXPORT void SetC (const Standard_Real theC); + + //! Returns field Gamma + Standard_EXPORT Standard_Real Gamma() const; + //! Sets field Gamma + Standard_EXPORT void SetGamma (const Standard_Real theGamma); + +DEFINE_STANDARD_RTTIEXT(StepGeom_SuParameters, StepGeom_GeometricRepresentationItem) + +private: + Standard_Real myA; + Standard_Real myAlpha; + Standard_Real myB; + Standard_Real myBeta; + Standard_Real myC; + Standard_Real myGamma; + +}; +#endif // _StepGeom_SuParameters_HeaderFile_ diff --git a/src/StepKinematics/FILES b/src/StepKinematics/FILES new file mode 100644 index 0000000000..7e884b996f --- /dev/null +++ b/src/StepKinematics/FILES @@ -0,0 +1,171 @@ +StepKinematics_ActuatedDirection.hxx +StepKinematics_ActuatedKinematicPair.cxx +StepKinematics_ActuatedKinematicPair.hxx +StepKinematics_ContextDependentKinematicLinkRepresentation.cxx +StepKinematics_ContextDependentKinematicLinkRepresentation.hxx +StepKinematics_CylindricalPair.cxx +StepKinematics_CylindricalPair.hxx +StepKinematics_CylindricalPairValue.cxx +StepKinematics_CylindricalPairValue.hxx +StepKinematics_CylindricalPairWithRange.cxx +StepKinematics_CylindricalPairWithRange.hxx +StepKinematics_FullyConstrainedPair.cxx +StepKinematics_FullyConstrainedPair.hxx +StepKinematics_GearPair.cxx +StepKinematics_GearPair.hxx +StepKinematics_GearPairValue.cxx +StepKinematics_GearPairValue.hxx +StepKinematics_GearPairWithRange.cxx +StepKinematics_GearPairWithRange.hxx +StepKinematics_HighOrderKinematicPair.cxx +StepKinematics_HighOrderKinematicPair.hxx +StepKinematics_HomokineticPair.cxx +StepKinematics_HomokineticPair.hxx +StepKinematics_KinematicJoint.cxx +StepKinematics_KinematicJoint.hxx +StepKinematics_KinematicLink.cxx +StepKinematics_KinematicLink.hxx +StepKinematics_KinematicLinkRepresentation.cxx +StepKinematics_KinematicLinkRepresentation.hxx +StepKinematics_KinematicLinkRepresentationAssociation.cxx +StepKinematics_KinematicLinkRepresentationAssociation.hxx +StepKinematics_KinematicPair.cxx +StepKinematics_KinematicPair.hxx +StepKinematics_ActuatedKinPairAndOrderKinPair.cxx +StepKinematics_ActuatedKinPairAndOrderKinPair.hxx +StepKinematics_KinematicPropertyDefinitionRepresentation.cxx +StepKinematics_KinematicPropertyDefinitionRepresentation.hxx +StepKinematics_KinematicPropertyMechanismRepresentation.cxx +StepKinematics_KinematicPropertyMechanismRepresentation.hxx +StepKinematics_KinematicTopologyStructure.cxx +StepKinematics_KinematicTopologyStructure.hxx +StepKinematics_LinearFlexibleAndPinionPair.cxx +StepKinematics_LinearFlexibleAndPinionPair.hxx +StepKinematics_LinearFlexibleAndPlanarCurvePair.cxx +StepKinematics_LinearFlexibleAndPlanarCurvePair.hxx +StepKinematics_LinearFlexibleLinkRepresentation.cxx +StepKinematics_LinearFlexibleLinkRepresentation.hxx +StepKinematics_LowOrderKinematicPair.cxx +StepKinematics_LowOrderKinematicPair.hxx +StepKinematics_LowOrderKinematicPairValue.cxx +StepKinematics_LowOrderKinematicPairValue.hxx +StepKinematics_LowOrderKinematicPairWithMotionCoupling.cxx +StepKinematics_LowOrderKinematicPairWithMotionCoupling.hxx +StepKinematics_LowOrderKinematicPairWithRange.cxx +StepKinematics_LowOrderKinematicPairWithRange.hxx +StepKinematics_MechanismRepresentation.cxx +StepKinematics_MechanismRepresentation.hxx +StepKinematics_MechanismStateRepresentation.cxx +StepKinematics_MechanismStateRepresentation.hxx +StepKinematics_OrientedJoint.cxx +StepKinematics_OrientedJoint.hxx +StepKinematics_PairRepresentationRelationship.cxx +StepKinematics_PairRepresentationRelationship.hxx +StepKinematics_PairValue.cxx +StepKinematics_PairValue.hxx +StepKinematics_PlanarCurvePair.cxx +StepKinematics_PlanarCurvePair.hxx +StepKinematics_PlanarCurvePairRange.cxx +StepKinematics_PlanarCurvePairRange.hxx +StepKinematics_PlanarPair.cxx +StepKinematics_PlanarPair.hxx +StepKinematics_PlanarPairValue.cxx +StepKinematics_PlanarPairValue.hxx +StepKinematics_PlanarPairWithRange.cxx +StepKinematics_PlanarPairWithRange.hxx +StepKinematics_PointOnPlanarCurvePair.cxx +StepKinematics_PointOnPlanarCurvePair.hxx +StepKinematics_PointOnPlanarCurvePairValue.cxx +StepKinematics_PointOnPlanarCurvePairValue.hxx +StepKinematics_PointOnPlanarCurvePairWithRange.cxx +StepKinematics_PointOnPlanarCurvePairWithRange.hxx +StepKinematics_PointOnSurfacePair.cxx +StepKinematics_PointOnSurfacePair.hxx +StepKinematics_PointOnSurfacePairValue.cxx +StepKinematics_PointOnSurfacePairValue.hxx +StepKinematics_PointOnSurfacePairWithRange.cxx +StepKinematics_PointOnSurfacePairWithRange.hxx +StepKinematics_PrismaticPair.cxx +StepKinematics_PrismaticPair.hxx +StepKinematics_PrismaticPairValue.cxx +StepKinematics_PrismaticPairValue.hxx +StepKinematics_PrismaticPairWithRange.cxx +StepKinematics_PrismaticPairWithRange.hxx +StepKinematics_ProductDefinitionKinematics.cxx +StepKinematics_ProductDefinitionKinematics.hxx +StepKinematics_ProductDefinitionRelationshipKinematics.cxx +StepKinematics_ProductDefinitionRelationshipKinematics.hxx +StepKinematics_RackAndPinionPair.cxx +StepKinematics_RackAndPinionPair.hxx +StepKinematics_RackAndPinionPairValue.cxx +StepKinematics_RackAndPinionPairValue.hxx +StepKinematics_RackAndPinionPairWithRange.cxx +StepKinematics_RackAndPinionPairWithRange.hxx +StepKinematics_RevolutePair.cxx +StepKinematics_RevolutePair.hxx +StepKinematics_RevolutePairValue.cxx +StepKinematics_RevolutePairValue.hxx +StepKinematics_RevolutePairWithRange.cxx +StepKinematics_RevolutePairWithRange.hxx +StepKinematics_RigidLinkRepresentation.cxx +StepKinematics_RigidLinkRepresentation.hxx +StepKinematics_RigidPlacement.cxx +StepKinematics_RigidPlacement.hxx +StepKinematics_RollingCurvePair.cxx +StepKinematics_RollingCurvePair.hxx +StepKinematics_RollingCurvePairValue.cxx +StepKinematics_RollingCurvePairValue.hxx +StepKinematics_RollingSurfacePair.cxx +StepKinematics_RollingSurfacePair.hxx +StepKinematics_RollingSurfacePairValue.cxx +StepKinematics_RollingSurfacePairValue.hxx +StepKinematics_RotationAboutDirection.cxx +StepKinematics_RotationAboutDirection.hxx +StepKinematics_ScrewPair.cxx +StepKinematics_ScrewPair.hxx +StepKinematics_ScrewPairValue.cxx +StepKinematics_ScrewPairValue.hxx +StepKinematics_ScrewPairWithRange.cxx +StepKinematics_ScrewPairWithRange.hxx +StepKinematics_SlidingCurvePair.cxx +StepKinematics_SlidingCurvePair.hxx +StepKinematics_SlidingCurvePairValue.cxx +StepKinematics_SlidingCurvePairValue.hxx +StepKinematics_SlidingSurfacePair.cxx +StepKinematics_SlidingSurfacePair.hxx +StepKinematics_SlidingSurfacePairValue.cxx +StepKinematics_SlidingSurfacePairValue.hxx +StepKinematics_SpatialRotation.cxx +StepKinematics_SpatialRotation.hxx +StepKinematics_SphericalPair.cxx +StepKinematics_SphericalPair.hxx +StepKinematics_SphericalPairSelect.cxx +StepKinematics_SphericalPairSelect.hxx +StepKinematics_SphericalPairValue.cxx +StepKinematics_SphericalPairValue.hxx +StepKinematics_SphericalPairWithPin.cxx +StepKinematics_SphericalPairWithPin.hxx +StepKinematics_SphericalPairWithPinAndRange.cxx +StepKinematics_SphericalPairWithPinAndRange.hxx +StepKinematics_SphericalPairWithRange.cxx +StepKinematics_SphericalPairWithRange.hxx +StepKinematics_SurfacePair.cxx +StepKinematics_SurfacePair.hxx +StepKinematics_SurfacePairWithRange.cxx +StepKinematics_SurfacePairWithRange.hxx +StepKinematics_KinematicTopologyDirectedStructure.cxx +StepKinematics_KinematicTopologyDirectedStructure.hxx +StepKinematics_KinematicTopologyNetworkStructure.cxx +StepKinematics_KinematicTopologyNetworkStructure.hxx +StepKinematics_KinematicTopologyRepresentationSelect.cxx +StepKinematics_KinematicTopologyRepresentationSelect.hxx +StepKinematics_UnconstrainedPair.cxx +StepKinematics_UnconstrainedPair.hxx +StepKinematics_UnconstrainedPairValue.cxx +StepKinematics_UnconstrainedPairValue.hxx +StepKinematics_UniversalPair.cxx +StepKinematics_UniversalPair.hxx +StepKinematics_UniversalPairValue.cxx +StepKinematics_UniversalPairValue.hxx +StepKinematics_UniversalPairWithRange.cxx +StepKinematics_UniversalPairWithRange.hxx \ No newline at end of file diff --git a/src/StepKinematics/StepKinematics_ActuatedDirection.hxx b/src/StepKinematics/StepKinematics_ActuatedDirection.hxx new file mode 100644 index 0000000000..81c3ca5888 --- /dev/null +++ b/src/StepKinematics/StepKinematics_ActuatedDirection.hxx @@ -0,0 +1,27 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_ActuatedDirection_HeaderFile +#define _StepKinematics_ActuatedDirection_HeaderFile + +enum StepKinematics_ActuatedDirection +{ + StepKinematics_adBidirectional, + StepKinematics_adPositiveOnly, + StepKinematics_adNegativeOnly, + StepKinematics_adNotActuated +}; +#endif // _StepKinematics_ActuatedDirection_HeaderFile diff --git a/src/StepKinematics/StepKinematics_ActuatedKinPairAndOrderKinPair.cxx b/src/StepKinematics/StepKinematics_ActuatedKinPairAndOrderKinPair.cxx new file mode 100644 index 0000000000..9b97de8684 --- /dev/null +++ b/src/StepKinematics/StepKinematics_ActuatedKinPairAndOrderKinPair.cxx @@ -0,0 +1,54 @@ +// Created on: 2020-05-26 +// Created by: PASUKHIN DMITRY +// Copyright (c) 2020 OPEN CASCADE SAS +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include +#include +#include +#include +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_ActuatedKinPairAndOrderKinPair, StepKinematics_KinematicPair) + +//======================================================================= +//function : StepKinematics_ActuatedKinPairAndOrderKinPair +//purpose : +//======================================================================= +StepKinematics_ActuatedKinPairAndOrderKinPair::StepKinematics_ActuatedKinPairAndOrderKinPair() +{} + +//======================================================================= +//function : Init +//purpose : +//======================================================================= +void StepKinematics_ActuatedKinPairAndOrderKinPair::Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name, + const Standard_Boolean hasItemDefinedTransformation_Description, + const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description, + const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1, + const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2, + const Handle(StepKinematics_KinematicJoint)& theJoint, + const Handle(StepKinematics_ActuatedKinematicPair)& theActuatedKinematicPair, + const Handle(StepKinematics_KinematicPair)& theOrderKinematicPair) +{ + StepKinematics_KinematicPair::Init(theRepresentationItem_Name, + theItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + theItemDefinedTransformation_Description, + theItemDefinedTransformation_TransformItem1, + theItemDefinedTransformation_TransformItem2, + theJoint); + SetActuatedKinematicPair(theActuatedKinematicPair); + SetOrderKinematicPair(theOrderKinematicPair); +} diff --git a/src/StepKinematics/StepKinematics_ActuatedKinPairAndOrderKinPair.hxx b/src/StepKinematics/StepKinematics_ActuatedKinPairAndOrderKinPair.hxx new file mode 100644 index 0000000000..e9e8b3ec5b --- /dev/null +++ b/src/StepKinematics/StepKinematics_ActuatedKinPairAndOrderKinPair.hxx @@ -0,0 +1,72 @@ +// Created on: 2020-05-26 +// Created by: PASUKHIN DMITRY +// Copyright (c) 2020 OPEN CASCADE SAS +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_ActuatedKinPairAndOrderKinPair_HeaderFile_ +#define _StepKinematics_ActuatedKinPairAndOrderKinPair_HeaderFile_ + +#include +#include +#include +#include +#include +#include +class StepRepr_RepresentationItem; +class StepKinematics_ActuatedKinematicPair; +class StepKinematics_ActuatedKinPairAndOrderKinPair; + +DEFINE_STANDARD_HANDLE(StepKinematics_ActuatedKinPairAndOrderKinPair, StepKinematics_KinematicPair) + +//! Representation of STEP entity ActuatedKinPairAndOrderKinPair +class StepKinematics_ActuatedKinPairAndOrderKinPair : public StepKinematics_KinematicPair +{ +public : + + //! default constructor + Standard_EXPORT StepKinematics_ActuatedKinPairAndOrderKinPair(); + + + Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name, + const Standard_Boolean hasItemDefinedTransformation_Description, + const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description, + const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1, + const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2, + const Handle(StepKinematics_KinematicJoint)& theJoint, + const Handle(StepKinematics_ActuatedKinematicPair)& theActuatedKinematicPair, + const Handle(StepKinematics_KinematicPair)& theOrderKinematicPair); + + inline void SetActuatedKinematicPair(const Handle(StepKinematics_ActuatedKinematicPair)& aKP) { + myActuatedKinematicPair = aKP; + } + + inline Handle(StepKinematics_ActuatedKinematicPair) GetActuatedKinematicPair() const { + return myActuatedKinematicPair; + } + inline void SetOrderKinematicPair(const Handle(StepKinematics_KinematicPair)& aKP) { + myOrderKinematicPair = aKP; + } + + inline Handle(StepKinematics_KinematicPair) GetOrderKinematicPair() const { + return myOrderKinematicPair; + } + + +DEFINE_STANDARD_RTTIEXT(StepKinematics_ActuatedKinPairAndOrderKinPair, StepKinematics_KinematicPair) + +private: + Handle(StepKinematics_ActuatedKinematicPair) myActuatedKinematicPair; + Handle(StepKinematics_KinematicPair) myOrderKinematicPair; +}; +#endif // StepKinematics_ActuatedKinPairAndOrderKinPair diff --git a/src/StepKinematics/StepKinematics_ActuatedKinematicPair.cxx b/src/StepKinematics/StepKinematics_ActuatedKinematicPair.cxx new file mode 100644 index 0000000000..123f8f3024 --- /dev/null +++ b/src/StepKinematics/StepKinematics_ActuatedKinematicPair.cxx @@ -0,0 +1,264 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..d7360a68b5 --- /dev/null +++ b/src/StepKinematics/StepKinematics_ActuatedKinematicPair.hxx @@ -0,0 +1,121 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_ActuatedKinematicPair_HeaderFile_ +#define _StepKinematics_ActuatedKinematicPair_HeaderFile_ + +#include +#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..358e62cad0 --- /dev/null +++ b/src/StepKinematics/StepKinematics_ContextDependentKinematicLinkRepresentation.cxx @@ -0,0 +1,76 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..fe94b4cb4b --- /dev/null +++ b/src/StepKinematics/StepKinematics_ContextDependentKinematicLinkRepresentation.hxx @@ -0,0 +1,58 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_ContextDependentKinematicLinkRepresentation_HeaderFile_ +#define _StepKinematics_ContextDependentKinematicLinkRepresentation_HeaderFile_ + +#include +#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..98c2a4dcc5 --- /dev/null +++ b/src/StepKinematics/StepKinematics_CylindricalPair.cxx @@ -0,0 +1,27 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..4c2740855b --- /dev/null +++ b/src/StepKinematics/StepKinematics_CylindricalPair.hxx @@ -0,0 +1,42 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_CylindricalPair_HeaderFile_ +#define _StepKinematics_CylindricalPair_HeaderFile_ + +#include +#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..ef143e8bb3 --- /dev/null +++ b/src/StepKinematics/StepKinematics_CylindricalPairValue.cxx @@ -0,0 +1,80 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_CylindricalPairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_CylindricalPairValue +//purpose : +//======================================================================= +StepKinematics_CylindricalPairValue::StepKinematics_CylindricalPairValue () +{ +} + +//======================================================================= +//function : Init +//purpose : +//======================================================================= +void StepKinematics_CylindricalPairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Standard_Real theActualTranslation, + const Standard_Real theActualRotation) +{ + StepKinematics_PairValue::Init(theRepresentationItem_Name, + thePairValue_AppliesToPair); + + myActualTranslation = theActualTranslation; + + myActualRotation = theActualRotation; +} + +//======================================================================= +//function : ActualTranslation +//purpose : +//======================================================================= +Standard_Real StepKinematics_CylindricalPairValue::ActualTranslation () const +{ + return myActualTranslation; +} + +//======================================================================= +//function : SetActualTranslation +//purpose : +//======================================================================= +void StepKinematics_CylindricalPairValue::SetActualTranslation (const Standard_Real theActualTranslation) +{ + myActualTranslation = theActualTranslation; +} + +//======================================================================= +//function : ActualRotation +//purpose : +//======================================================================= +Standard_Real StepKinematics_CylindricalPairValue::ActualRotation () const +{ + return myActualRotation; +} + +//======================================================================= +//function : SetActualRotation +//purpose : +//======================================================================= +void StepKinematics_CylindricalPairValue::SetActualRotation (const Standard_Real theActualRotation) +{ + myActualRotation = theActualRotation; +} diff --git a/src/StepKinematics/StepKinematics_CylindricalPairValue.hxx b/src/StepKinematics/StepKinematics_CylindricalPairValue.hxx new file mode 100644 index 0000000000..2222a8750f --- /dev/null +++ b/src/StepKinematics/StepKinematics_CylindricalPairValue.hxx @@ -0,0 +1,60 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_CylindricalPairValue_HeaderFile_ +#define _StepKinematics_CylindricalPairValue_HeaderFile_ + +#include +#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(); + + //! Initialize all fields (own and inherited) + Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Standard_Real theActualTranslation, + const Standard_Real theActualRotation); + + //! Returns field ActualTranslation + Standard_EXPORT Standard_Real ActualTranslation() const; + //! Sets field ActualTranslation + Standard_EXPORT void SetActualTranslation (const Standard_Real theActualTranslation); + + //! Returns field ActualRotation + Standard_EXPORT Standard_Real ActualRotation() const; + //! Sets field ActualRotation + Standard_EXPORT void SetActualRotation (const Standard_Real theActualRotation); + +DEFINE_STANDARD_RTTIEXT(StepKinematics_CylindricalPairValue, StepKinematics_PairValue) + +private: + Standard_Real myActualTranslation; + Standard_Real myActualRotation; + +}; +#endif // _StepKinematics_CylindricalPairValue_HeaderFile_ diff --git a/src/StepKinematics/StepKinematics_CylindricalPairWithRange.cxx b/src/StepKinematics/StepKinematics_CylindricalPairWithRange.cxx new file mode 100644 index 0000000000..81dbb23807 --- /dev/null +++ b/src/StepKinematics/StepKinematics_CylindricalPairWithRange.cxx @@ -0,0 +1,204 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..74393e425b --- /dev/null +++ b/src/StepKinematics/StepKinematics_CylindricalPairWithRange.hxx @@ -0,0 +1,103 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_CylindricalPairWithRange_HeaderFile_ +#define _StepKinematics_CylindricalPairWithRange_HeaderFile_ + +#include +#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..7aa923da30 --- /dev/null +++ b/src/StepKinematics/StepKinematics_FullyConstrainedPair.cxx @@ -0,0 +1,27 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..573f7cce74 --- /dev/null +++ b/src/StepKinematics/StepKinematics_FullyConstrainedPair.hxx @@ -0,0 +1,42 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_FullyConstrainedPair_HeaderFile_ +#define _StepKinematics_FullyConstrainedPair_HeaderFile_ + +#include +#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..07c4c5c4ae --- /dev/null +++ b/src/StepKinematics/StepKinematics_GearPair.cxx @@ -0,0 +1,153 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..493a7d3766 --- /dev/null +++ b/src/StepKinematics/StepKinematics_GearPair.hxx @@ -0,0 +1,88 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_GearPair_HeaderFile_ +#define _StepKinematics_GearPair_HeaderFile_ + +#include +#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..a91f3940ea --- /dev/null +++ b/src/StepKinematics/StepKinematics_GearPairValue.cxx @@ -0,0 +1,59 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_GearPairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_GearPairValue +//purpose : +//======================================================================= +StepKinematics_GearPairValue::StepKinematics_GearPairValue () +{ +} + +//======================================================================= +//function : Init +//purpose : +//======================================================================= +void StepKinematics_GearPairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Standard_Real theActualRotation1) +{ + StepKinematics_PairValue::Init(theRepresentationItem_Name, + thePairValue_AppliesToPair); + + myActualRotation1 = theActualRotation1; +} + +//======================================================================= +//function : ActualRotation1 +//purpose : +//======================================================================= +Standard_Real StepKinematics_GearPairValue::ActualRotation1 () const +{ + return myActualRotation1; +} + +//======================================================================= +//function : SetActualRotation1 +//purpose : +//======================================================================= +void StepKinematics_GearPairValue::SetActualRotation1 (const Standard_Real theActualRotation1) +{ + myActualRotation1 = theActualRotation1; +} diff --git a/src/StepKinematics/StepKinematics_GearPairValue.hxx b/src/StepKinematics/StepKinematics_GearPairValue.hxx new file mode 100644 index 0000000000..8c8a2eb2ec --- /dev/null +++ b/src/StepKinematics/StepKinematics_GearPairValue.hxx @@ -0,0 +1,53 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_GearPairValue_HeaderFile_ +#define _StepKinematics_GearPairValue_HeaderFile_ + +#include +#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(); + + //! Initialize all fields (own and inherited) + Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Standard_Real theActualRotation1); + + //! Returns field ActualRotation1 + Standard_EXPORT Standard_Real ActualRotation1() const; + //! Sets field ActualRotation1 + Standard_EXPORT void SetActualRotation1 (const Standard_Real theActualRotation1); + +DEFINE_STANDARD_RTTIEXT(StepKinematics_GearPairValue, StepKinematics_PairValue) + +private: + Standard_Real myActualRotation1; + +}; +#endif // _StepKinematics_GearPairValue_HeaderFile_ diff --git a/src/StepKinematics/StepKinematics_GearPairWithRange.cxx b/src/StepKinematics/StepKinematics_GearPairWithRange.cxx new file mode 100644 index 0000000000..4e2448f80a --- /dev/null +++ b/src/StepKinematics/StepKinematics_GearPairWithRange.cxx @@ -0,0 +1,130 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..8f011aa9ab --- /dev/null +++ b/src/StepKinematics/StepKinematics_GearPairWithRange.hxx @@ -0,0 +1,80 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_GearPairWithRange_HeaderFile_ +#define _StepKinematics_GearPairWithRange_HeaderFile_ + +#include +#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..281af578ed --- /dev/null +++ b/src/StepKinematics/StepKinematics_HighOrderKinematicPair.cxx @@ -0,0 +1,27 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..40930a83fe --- /dev/null +++ b/src/StepKinematics/StepKinematics_HighOrderKinematicPair.hxx @@ -0,0 +1,42 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_HighOrderKinematicPair_HeaderFile_ +#define _StepKinematics_HighOrderKinematicPair_HeaderFile_ + +#include +#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..017bc00ce4 --- /dev/null +++ b/src/StepKinematics/StepKinematics_HomokineticPair.cxx @@ -0,0 +1,27 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..fa60e49701 --- /dev/null +++ b/src/StepKinematics/StepKinematics_HomokineticPair.hxx @@ -0,0 +1,42 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_HomokineticPair_HeaderFile_ +#define _StepKinematics_HomokineticPair_HeaderFile_ + +#include +#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..1ce2c403ff --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicJoint.cxx @@ -0,0 +1,27 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..be7a2622c6 --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicJoint.hxx @@ -0,0 +1,40 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_KinematicJoint_HeaderFile_ +#define _StepKinematics_KinematicJoint_HeaderFile_ + +#include +#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..cfb1a09657 --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicLink.cxx @@ -0,0 +1,27 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..14ed0dafcf --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicLink.hxx @@ -0,0 +1,39 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_KinematicLink_HeaderFile_ +#define _StepKinematics_KinematicLink_HeaderFile_ + +#include +#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..96937268da --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicLinkRepresentation.cxx @@ -0,0 +1,61 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_KinematicLinkRepresentation, StepRepr_Representation) + +//======================================================================= +//function : StepKinematics_KinematicLinkRepresentation +//purpose : +//======================================================================= +StepKinematics_KinematicLinkRepresentation::StepKinematics_KinematicLinkRepresentation () +{ +} + +//======================================================================= +//function : Init +//purpose : +//======================================================================= +void StepKinematics_KinematicLinkRepresentation::Init (const Handle(TCollection_HAsciiString)& theRepresentation_Name, + const Handle(StepRepr_HArray1OfRepresentationItem)& theRepresentation_Items, + const Handle(StepRepr_RepresentationContext)& theRepresentation_ContextOfItems, + const Handle(StepKinematics_KinematicLink)& theRepresentedLink) +{ + StepRepr_Representation::Init(theRepresentation_Name, + theRepresentation_Items, + theRepresentation_ContextOfItems); + + myRepresentedLink = theRepresentedLink; +} + +//======================================================================= +//function : RepresentedLink +//purpose : +//======================================================================= +Handle(StepKinematics_KinematicLink) StepKinematics_KinematicLinkRepresentation::RepresentedLink () const +{ + return myRepresentedLink; +} + +//======================================================================= +//function : SetRepresentedLink +//purpose : +//======================================================================= +void StepKinematics_KinematicLinkRepresentation::SetRepresentedLink (const Handle(StepKinematics_KinematicLink)& theRepresentedLink) +{ + myRepresentedLink = theRepresentedLink; +} diff --git a/src/StepKinematics/StepKinematics_KinematicLinkRepresentation.hxx b/src/StepKinematics/StepKinematics_KinematicLinkRepresentation.hxx new file mode 100644 index 0000000000..e042105f1c --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicLinkRepresentation.hxx @@ -0,0 +1,56 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_KinematicLinkRepresentation_HeaderFile_ +#define _StepKinematics_KinematicLinkRepresentation_HeaderFile_ + +#include +#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(); + + //! Initialize all fields (own and inherited) + Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentation_Name, + const Handle(StepRepr_HArray1OfRepresentationItem)& theRepresentation_Items, + const Handle(StepRepr_RepresentationContext)& theRepresentation_ContextOfItems, + const Handle(StepKinematics_KinematicLink)& theRepresentedLink); + + //! Returns field RepresentedLink + Standard_EXPORT Handle(StepKinematics_KinematicLink) RepresentedLink() const; + //! Sets field RepresentedLink + Standard_EXPORT void SetRepresentedLink (const Handle(StepKinematics_KinematicLink)& theRepresentedLink); + +DEFINE_STANDARD_RTTIEXT(StepKinematics_KinematicLinkRepresentation, StepRepr_Representation) + +private: + Handle(StepKinematics_KinematicLink) myRepresentedLink; + +}; +#endif // _StepKinematics_KinematicLinkRepresentation_HeaderFile_ diff --git a/src/StepKinematics/StepKinematics_KinematicLinkRepresentationAssociation.cxx b/src/StepKinematics/StepKinematics_KinematicLinkRepresentationAssociation.cxx new file mode 100644 index 0000000000..bd3bda23a2 --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicLinkRepresentationAssociation.cxx @@ -0,0 +1,27 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..e20ccad9d2 --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicLinkRepresentationAssociation.hxx @@ -0,0 +1,40 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_KinematicLinkRepresentationAssociation_HeaderFile_ +#define _StepKinematics_KinematicLinkRepresentationAssociation_HeaderFile_ + +#include +#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..4aeee107a8 --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicPair.cxx @@ -0,0 +1,86 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..8e34b1652a --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicPair.hxx @@ -0,0 +1,65 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_KinematicPair_HeaderFile_ +#define _StepKinematics_KinematicPair_HeaderFile_ + +#include +#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..2c84c91bab --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicPropertyDefinitionRepresentation.cxx @@ -0,0 +1,27 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..d2924497b0 --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicPropertyDefinitionRepresentation.hxx @@ -0,0 +1,40 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_KinematicPropertyDefinitionRepresentation_HeaderFile_ +#define _StepKinematics_KinematicPropertyDefinitionRepresentation_HeaderFile_ + +#include +#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..a47dfe2fd2 --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicPropertyMechanismRepresentation.cxx @@ -0,0 +1,59 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_KinematicPropertyMechanismRepresentation, StepKinematics_KinematicPropertyDefinitionRepresentation) + +//======================================================================= +//function : StepKinematics_KinematicPropertyMechanismRepresentation +//purpose : +//======================================================================= +StepKinematics_KinematicPropertyMechanismRepresentation::StepKinematics_KinematicPropertyMechanismRepresentation () +{ +} + +//======================================================================= +//function : Init +//purpose : +//======================================================================= +void StepKinematics_KinematicPropertyMechanismRepresentation::Init (const StepRepr_RepresentedDefinition& thePropertyDefinitionRepresentation_Definition, + const Handle(StepRepr_Representation)& thePropertyDefinitionRepresentation_UsedRepresentation, + const Handle(StepKinematics_KinematicLinkRepresentation)& theBase) +{ + StepKinematics_KinematicPropertyDefinitionRepresentation::Init(thePropertyDefinitionRepresentation_Definition, + thePropertyDefinitionRepresentation_UsedRepresentation); + + myBase = theBase; +} + +//======================================================================= +//function : Base +//purpose : +//======================================================================= +Handle(StepKinematics_KinematicLinkRepresentation) StepKinematics_KinematicPropertyMechanismRepresentation::Base () const +{ + return myBase; +} + +//======================================================================= +//function : SetBase +//purpose : +//======================================================================= +void StepKinematics_KinematicPropertyMechanismRepresentation::SetBase (const Handle(StepKinematics_KinematicLinkRepresentation)& theBase) +{ + myBase = theBase; +} diff --git a/src/StepKinematics/StepKinematics_KinematicPropertyMechanismRepresentation.hxx b/src/StepKinematics/StepKinematics_KinematicPropertyMechanismRepresentation.hxx new file mode 100644 index 0000000000..9eb6cc66b9 --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicPropertyMechanismRepresentation.hxx @@ -0,0 +1,54 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_KinematicPropertyMechanismRepresentation_HeaderFile_ +#define _StepKinematics_KinematicPropertyMechanismRepresentation_HeaderFile_ + +#include +#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(); + + //! Initialize all fields (own and inherited) + Standard_EXPORT void Init(const StepRepr_RepresentedDefinition& thePropertyDefinitionRepresentation_Definition, + const Handle(StepRepr_Representation)& thePropertyDefinitionRepresentation_UsedRepresentation, + const Handle(StepKinematics_KinematicLinkRepresentation)& theBase); + + //! Returns field Base + Standard_EXPORT Handle(StepKinematics_KinematicLinkRepresentation) Base() const; + //! Sets field Base + Standard_EXPORT void SetBase (const Handle(StepKinematics_KinematicLinkRepresentation)& theBase); + +DEFINE_STANDARD_RTTIEXT(StepKinematics_KinematicPropertyMechanismRepresentation, StepKinematics_KinematicPropertyDefinitionRepresentation) + +private: + Handle(StepKinematics_KinematicLinkRepresentation) myBase; + +}; +#endif // _StepKinematics_KinematicPropertyMechanismRepresentation_HeaderFile_ diff --git a/src/StepKinematics/StepKinematics_KinematicTopologyDirectedStructure.cxx b/src/StepKinematics/StepKinematics_KinematicTopologyDirectedStructure.cxx new file mode 100644 index 0000000000..540ca4fc40 --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicTopologyDirectedStructure.cxx @@ -0,0 +1,61 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_KinematicTopologyDirectedStructure, StepRepr_Representation) + +//======================================================================= +//function : StepKinematics_KinematicTopologyDirectedStructure +//purpose : +//======================================================================= +StepKinematics_KinematicTopologyDirectedStructure::StepKinematics_KinematicTopologyDirectedStructure () +{ +} + +//======================================================================= +//function : Init +//purpose : +//======================================================================= +void StepKinematics_KinematicTopologyDirectedStructure::Init (const Handle(TCollection_HAsciiString)& theRepresentation_Name, + const Handle(StepRepr_HArray1OfRepresentationItem)& theRepresentation_Items, + const Handle(StepRepr_RepresentationContext)& theRepresentation_ContextOfItems, + const Handle(StepKinematics_KinematicTopologyStructure)& theParent) +{ + StepRepr_Representation::Init(theRepresentation_Name, + theRepresentation_Items, + theRepresentation_ContextOfItems); + + myParent = theParent; +} + +//======================================================================= +//function : Parent +//purpose : +//======================================================================= +Handle(StepKinematics_KinematicTopologyStructure) StepKinematics_KinematicTopologyDirectedStructure::Parent () const +{ + return myParent; +} + +//======================================================================= +//function : SetParent +//purpose : +//======================================================================= +void StepKinematics_KinematicTopologyDirectedStructure::SetParent (const Handle(StepKinematics_KinematicTopologyStructure)& theParent) +{ + myParent = theParent; +} diff --git a/src/StepKinematics/StepKinematics_KinematicTopologyDirectedStructure.hxx b/src/StepKinematics/StepKinematics_KinematicTopologyDirectedStructure.hxx new file mode 100644 index 0000000000..1ff25be00a --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicTopologyDirectedStructure.hxx @@ -0,0 +1,56 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_KinematicTopologyDirectedStructure_HeaderFile_ +#define _StepKinematics_KinematicTopologyDirectedStructure_HeaderFile_ + +#include +#include +#include + +#include +#include +#include +#include + +DEFINE_STANDARD_HANDLE(StepKinematics_KinematicTopologyDirectedStructure, StepRepr_Representation) + +//! Representation of STEP entity KinematicTopologyDirectedStructure +class StepKinematics_KinematicTopologyDirectedStructure : public StepRepr_Representation +{ +public : + + //! default constructor + Standard_EXPORT StepKinematics_KinematicTopologyDirectedStructure(); + + //! Initialize all fields (own and inherited) + Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentation_Name, + const Handle(StepRepr_HArray1OfRepresentationItem)& theRepresentation_Items, + const Handle(StepRepr_RepresentationContext)& theRepresentation_ContextOfItems, + const Handle(StepKinematics_KinematicTopologyStructure)& theParent); + + //! Returns field Parent + Standard_EXPORT Handle(StepKinematics_KinematicTopologyStructure) Parent() const; + //! Sets field Parent + Standard_EXPORT void SetParent (const Handle(StepKinematics_KinematicTopologyStructure)& theParent); + +DEFINE_STANDARD_RTTIEXT(StepKinematics_KinematicTopologyDirectedStructure, StepRepr_Representation) + +private: + Handle(StepKinematics_KinematicTopologyStructure) myParent; + +}; +#endif // _StepKinematics_KinematicTopologyDirectedStructure_HeaderFile_ diff --git a/src/StepKinematics/StepKinematics_KinematicTopologyNetworkStructure.cxx b/src/StepKinematics/StepKinematics_KinematicTopologyNetworkStructure.cxx new file mode 100644 index 0000000000..5f9c86ee0b --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicTopologyNetworkStructure.cxx @@ -0,0 +1,61 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_KinematicTopologyNetworkStructure, StepRepr_Representation) + +//======================================================================= +//function : StepKinematics_KinematicTopologyNetworkStructure +//purpose : +//======================================================================= +StepKinematics_KinematicTopologyNetworkStructure::StepKinematics_KinematicTopologyNetworkStructure () +{ +} + +//======================================================================= +//function : Init +//purpose : +//======================================================================= +void StepKinematics_KinematicTopologyNetworkStructure::Init (const Handle(TCollection_HAsciiString)& theRepresentation_Name, + const Handle(StepRepr_HArray1OfRepresentationItem)& theRepresentation_Items, + const Handle(StepRepr_RepresentationContext)& theRepresentation_ContextOfItems, + const Handle(StepKinematics_KinematicTopologyStructure)& theParent) +{ + StepRepr_Representation::Init(theRepresentation_Name, + theRepresentation_Items, + theRepresentation_ContextOfItems); + + myParent = theParent; +} + +//======================================================================= +//function : Parent +//purpose : +//======================================================================= +Handle(StepKinematics_KinematicTopologyStructure) StepKinematics_KinematicTopologyNetworkStructure::Parent () const +{ + return myParent; +} + +//======================================================================= +//function : SetParent +//purpose : +//======================================================================= +void StepKinematics_KinematicTopologyNetworkStructure::SetParent (const Handle(StepKinematics_KinematicTopologyStructure)& theParent) +{ + myParent = theParent; +} diff --git a/src/StepKinematics/StepKinematics_KinematicTopologyNetworkStructure.hxx b/src/StepKinematics/StepKinematics_KinematicTopologyNetworkStructure.hxx new file mode 100644 index 0000000000..4a2801685a --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicTopologyNetworkStructure.hxx @@ -0,0 +1,56 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_KinematicTopologyNetworkStructure_HeaderFile_ +#define _StepKinematics_KinematicTopologyNetworkStructure_HeaderFile_ + +#include +#include +#include + +#include +#include +#include +#include + +DEFINE_STANDARD_HANDLE(StepKinematics_KinematicTopologyNetworkStructure, StepRepr_Representation) + +//! Representation of STEP entity KinematicTopologyNetworkStructure +class StepKinematics_KinematicTopologyNetworkStructure : public StepRepr_Representation +{ +public : + + //! default constructor + Standard_EXPORT StepKinematics_KinematicTopologyNetworkStructure(); + + //! Initialize all fields (own and inherited) + Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentation_Name, + const Handle(StepRepr_HArray1OfRepresentationItem)& theRepresentation_Items, + const Handle(StepRepr_RepresentationContext)& theRepresentation_ContextOfItems, + const Handle(StepKinematics_KinematicTopologyStructure)& theParent); + + //! Returns field Parent + Standard_EXPORT Handle(StepKinematics_KinematicTopologyStructure) Parent() const; + //! Sets field Parent + Standard_EXPORT void SetParent (const Handle(StepKinematics_KinematicTopologyStructure)& theParent); + +DEFINE_STANDARD_RTTIEXT(StepKinematics_KinematicTopologyNetworkStructure, StepRepr_Representation) + +private: + Handle(StepKinematics_KinematicTopologyStructure) myParent; + +}; +#endif // _StepKinematics_KinematicTopologyNetworkStructure_HeaderFile_ diff --git a/src/StepKinematics/StepKinematics_KinematicTopologyRepresentationSelect.cxx b/src/StepKinematics/StepKinematics_KinematicTopologyRepresentationSelect.cxx new file mode 100644 index 0000000000..a4f228545d --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicTopologyRepresentationSelect.cxx @@ -0,0 +1,69 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +#include +#include +#include + +//======================================================================= +//function : StepKinematics_KinematicTopologyRepresentationSelect +//purpose : +//======================================================================= +StepKinematics_KinematicTopologyRepresentationSelect::StepKinematics_KinematicTopologyRepresentationSelect () +{ +} + +//======================================================================= +//function : CaseNum +//purpose : +//======================================================================= +Standard_Integer StepKinematics_KinematicTopologyRepresentationSelect::CaseNum (const Handle(Standard_Transient)& ent) const +{ + if (ent.IsNull()) return 0; + if (ent->IsKind(STANDARD_TYPE(StepKinematics_KinematicTopologyDirectedStructure))) return 1; + if (ent->IsKind(STANDARD_TYPE(StepKinematics_KinematicTopologyNetworkStructure))) return 2; + if (ent->IsKind(STANDARD_TYPE(StepKinematics_KinematicTopologyStructure))) return 3; + return 0; +} + +//======================================================================= +//function : KinematicTopologyDirectedStructure +//purpose : +//======================================================================= +Handle(StepKinematics_KinematicTopologyDirectedStructure) StepKinematics_KinematicTopologyRepresentationSelect::KinematicTopologyDirectedStructure () const +{ + return Handle(StepKinematics_KinematicTopologyDirectedStructure)::DownCast(Value()); +} + +//======================================================================= +//function : KinematicTopologyNetworkStructure +//purpose : +//======================================================================= +Handle(StepKinematics_KinematicTopologyNetworkStructure) StepKinematics_KinematicTopologyRepresentationSelect::KinematicTopologyNetworkStructure () const +{ + return Handle(StepKinematics_KinematicTopologyNetworkStructure)::DownCast(Value()); +} + +//======================================================================= +//function : KinematicTopologyStructure +//purpose : +//======================================================================= +Handle(StepKinematics_KinematicTopologyStructure) StepKinematics_KinematicTopologyRepresentationSelect::KinematicTopologyStructure () const +{ + return Handle(StepKinematics_KinematicTopologyStructure)::DownCast(Value()); +} diff --git a/src/StepKinematics/StepKinematics_KinematicTopologyRepresentationSelect.hxx b/src/StepKinematics/StepKinematics_KinematicTopologyRepresentationSelect.hxx new file mode 100644 index 0000000000..3d6d89c095 --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicTopologyRepresentationSelect.hxx @@ -0,0 +1,58 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_KinematicTopologyRepresentationSelect_HeaderFile +#define _StepKinematics_KinematicTopologyRepresentationSelect_HeaderFile + +#include +#include +#include +#include +#include + +class Standard_Transient; +class StepKinematics_KinematicTopologyDirectedStructure; +class StepKinematics_KinematicTopologyNetworkStructure; +class StepKinematics_KinematicTopologyStructure; + +//! Representation of STEP SELECT type KinematicTopologyRepresentationSelect +class StepKinematics_KinematicTopologyRepresentationSelect : public StepData_SelectType +{ + +public: + + DEFINE_STANDARD_ALLOC + + //! Empty constructor + Standard_EXPORT StepKinematics_KinematicTopologyRepresentationSelect(); + + //! Recognizes a kind of KinematicTopologyRepresentationSelect select type + //! -- 1 -> KinematicTopologyDirectedStructure + //! -- 2 -> KinematicTopologyNetworkStructure + //! -- 3 -> KinematicTopologyStructure + Standard_EXPORT Standard_Integer CaseNum (const Handle(Standard_Transient)& ent) const Standard_OVERRIDE; + + //! Returns Value as KinematicTopologyDirectedStructure (or Null if another type) + Standard_EXPORT Handle(StepKinematics_KinematicTopologyDirectedStructure) KinematicTopologyDirectedStructure() const; + + //! Returns Value as KinematicTopologyNetworkStructure (or Null if another type) + Standard_EXPORT Handle(StepKinematics_KinematicTopologyNetworkStructure) KinematicTopologyNetworkStructure() const; + + //! Returns Value as KinematicTopologyStructure (or Null if another type) + Standard_EXPORT Handle(StepKinematics_KinematicTopologyStructure) KinematicTopologyStructure() const; + +}; +#endif // _StepKinematics_KinematicTopologyRepresentationSelect_HeaderFile diff --git a/src/StepKinematics/StepKinematics_KinematicTopologyStructure.cxx b/src/StepKinematics/StepKinematics_KinematicTopologyStructure.cxx new file mode 100644 index 0000000000..d207bb113d --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicTopologyStructure.cxx @@ -0,0 +1,27 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..8359003836 --- /dev/null +++ b/src/StepKinematics/StepKinematics_KinematicTopologyStructure.hxx @@ -0,0 +1,41 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_KinematicTopologyStructure_HeaderFile_ +#define _StepKinematics_KinematicTopologyStructure_HeaderFile_ + +#include +#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_LinearFlexibleAndPinionPair.cxx b/src/StepKinematics/StepKinematics_LinearFlexibleAndPinionPair.cxx new file mode 100644 index 0000000000..7b3a7826ac --- /dev/null +++ b/src/StepKinematics/StepKinematics_LinearFlexibleAndPinionPair.cxx @@ -0,0 +1,69 @@ +// Created on : Fri May 08 19:02:07 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_LinearFlexibleAndPinionPair, StepKinematics_LowOrderKinematicPairWithMotionCoupling) + +//======================================================================= +//function : StepKinematics_LinearFlexibleAndPinionPair +//purpose : +//======================================================================= +StepKinematics_LinearFlexibleAndPinionPair::StepKinematics_LinearFlexibleAndPinionPair () +{ +} + +//======================================================================= +//function : Init +//purpose : +//======================================================================= +void StepKinematics_LinearFlexibleAndPinionPair::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name, + const Standard_Boolean hasItemDefinedTransformation_Description, + const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description, + const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1, + const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2, + const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint, + const Standard_Real thePinionRadius) +{ + StepKinematics_LowOrderKinematicPairWithMotionCoupling::Init(theRepresentationItem_Name, + theItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + theItemDefinedTransformation_Description, + theItemDefinedTransformation_TransformItem1, + theItemDefinedTransformation_TransformItem2, + theKinematicPair_Joint); + + myPinionRadius = thePinionRadius; +} + +//======================================================================= +//function : PinionRadius +//purpose : +//======================================================================= +Standard_Real StepKinematics_LinearFlexibleAndPinionPair::PinionRadius () const +{ + return myPinionRadius; +} + +//======================================================================= +//function : SetPinionRadius +//purpose : +//======================================================================= +void StepKinematics_LinearFlexibleAndPinionPair::SetPinionRadius (const Standard_Real thePinionRadius) +{ + myPinionRadius = thePinionRadius; +} diff --git a/src/StepKinematics/StepKinematics_LinearFlexibleAndPinionPair.hxx b/src/StepKinematics/StepKinematics_LinearFlexibleAndPinionPair.hxx new file mode 100644 index 0000000000..966e2859de --- /dev/null +++ b/src/StepKinematics/StepKinematics_LinearFlexibleAndPinionPair.hxx @@ -0,0 +1,60 @@ +// Created on : Fri May 08 19:02:07 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_LinearFlexibleAndPinionPair_HeaderFile_ +#define _StepKinematics_LinearFlexibleAndPinionPair_HeaderFile_ + +#include +#include +#include + +#include +#include +#include +#include + +DEFINE_STANDARD_HANDLE(StepKinematics_LinearFlexibleAndPinionPair, StepKinematics_LowOrderKinematicPairWithMotionCoupling) + +//! Representation of STEP entity LinearFlexibleAndPinionPair +class StepKinematics_LinearFlexibleAndPinionPair : public StepKinematics_LowOrderKinematicPairWithMotionCoupling +{ +public : + + //! default constructor + Standard_EXPORT StepKinematics_LinearFlexibleAndPinionPair(); + + //! Initialize all fields (own and inherited) + Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name, + const Standard_Boolean hasItemDefinedTransformation_Description, + const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description, + const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1, + const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2, + const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint, + const Standard_Real thePinionRadius); + + //! Returns field PinionRadius + Standard_EXPORT Standard_Real PinionRadius() const; + //! Sets field PinionRadius + Standard_EXPORT void SetPinionRadius (const Standard_Real thePinionRadius); + +DEFINE_STANDARD_RTTIEXT(StepKinematics_LinearFlexibleAndPinionPair, StepKinematics_LowOrderKinematicPairWithMotionCoupling) + +private: + Standard_Real myPinionRadius; + +}; +#endif // _StepKinematics_LinearFlexibleAndPinionPair_HeaderFile_ diff --git a/src/StepKinematics/StepKinematics_LinearFlexibleAndPlanarCurvePair.cxx b/src/StepKinematics/StepKinematics_LinearFlexibleAndPlanarCurvePair.cxx new file mode 100644 index 0000000000..5f74b551c8 --- /dev/null +++ b/src/StepKinematics/StepKinematics_LinearFlexibleAndPlanarCurvePair.cxx @@ -0,0 +1,90 @@ +// Created on : Fri May 08 19:02:07 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_LinearFlexibleAndPlanarCurvePair, StepKinematics_HighOrderKinematicPair) + +//======================================================================= +//function : StepKinematics_LinearFlexibleAndPlanarCurvePair +//purpose : +//======================================================================= +StepKinematics_LinearFlexibleAndPlanarCurvePair::StepKinematics_LinearFlexibleAndPlanarCurvePair () +{ +} + +//======================================================================= +//function : Init +//purpose : +//======================================================================= +void StepKinematics_LinearFlexibleAndPlanarCurvePair::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name, + const Standard_Boolean hasItemDefinedTransformation_Description, + const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description, + const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1, + const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2, + const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint, + const Handle(StepGeom_Curve)& thePairCurve, + const Standard_Boolean theOrientation) +{ + StepKinematics_HighOrderKinematicPair::Init(theRepresentationItem_Name, + theItemDefinedTransformation_Name, + hasItemDefinedTransformation_Description, + theItemDefinedTransformation_Description, + theItemDefinedTransformation_TransformItem1, + theItemDefinedTransformation_TransformItem2, + theKinematicPair_Joint); + + myPairCurve = thePairCurve; + + myOrientation = theOrientation; +} + +//======================================================================= +//function : PairCurve +//purpose : +//======================================================================= +Handle(StepGeom_Curve) StepKinematics_LinearFlexibleAndPlanarCurvePair::PairCurve () const +{ + return myPairCurve; +} + +//======================================================================= +//function : SetPairCurve +//purpose : +//======================================================================= +void StepKinematics_LinearFlexibleAndPlanarCurvePair::SetPairCurve (const Handle(StepGeom_Curve)& thePairCurve) +{ + myPairCurve = thePairCurve; +} + +//======================================================================= +//function : Orientation +//purpose : +//======================================================================= +Standard_Boolean StepKinematics_LinearFlexibleAndPlanarCurvePair::Orientation () const +{ + return myOrientation; +} + +//======================================================================= +//function : SetOrientation +//purpose : +//======================================================================= +void StepKinematics_LinearFlexibleAndPlanarCurvePair::SetOrientation (const Standard_Boolean theOrientation) +{ + myOrientation = theOrientation; +} diff --git a/src/StepKinematics/StepKinematics_LinearFlexibleAndPlanarCurvePair.hxx b/src/StepKinematics/StepKinematics_LinearFlexibleAndPlanarCurvePair.hxx new file mode 100644 index 0000000000..22c4b3c346 --- /dev/null +++ b/src/StepKinematics/StepKinematics_LinearFlexibleAndPlanarCurvePair.hxx @@ -0,0 +1,68 @@ +// Created on : Fri May 08 19:02:07 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_LinearFlexibleAndPlanarCurvePair_HeaderFile_ +#define _StepKinematics_LinearFlexibleAndPlanarCurvePair_HeaderFile_ + +#include +#include +#include + +#include +#include +#include +#include +#include + +DEFINE_STANDARD_HANDLE(StepKinematics_LinearFlexibleAndPlanarCurvePair, StepKinematics_HighOrderKinematicPair) + +//! Representation of STEP entity LinearFlexibleAndPlanarCurvePair +class StepKinematics_LinearFlexibleAndPlanarCurvePair : public StepKinematics_HighOrderKinematicPair +{ +public : + + //! default constructor + Standard_EXPORT StepKinematics_LinearFlexibleAndPlanarCurvePair(); + + //! Initialize all fields (own and inherited) + Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Name, + const Standard_Boolean hasItemDefinedTransformation_Description, + const Handle(TCollection_HAsciiString)& theItemDefinedTransformation_Description, + const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem1, + const Handle(StepRepr_RepresentationItem)& theItemDefinedTransformation_TransformItem2, + const Handle(StepKinematics_KinematicJoint)& theKinematicPair_Joint, + const Handle(StepGeom_Curve)& thePairCurve, + const Standard_Boolean theOrientation); + + //! Returns field PairCurve + Standard_EXPORT Handle(StepGeom_Curve) PairCurve() const; + //! Sets field PairCurve + Standard_EXPORT void SetPairCurve (const Handle(StepGeom_Curve)& thePairCurve); + + //! Returns field Orientation + Standard_EXPORT Standard_Boolean Orientation() const; + //! Sets field Orientation + Standard_EXPORT void SetOrientation (const Standard_Boolean theOrientation); + +DEFINE_STANDARD_RTTIEXT(StepKinematics_LinearFlexibleAndPlanarCurvePair, StepKinematics_HighOrderKinematicPair) + +private: + Handle(StepGeom_Curve) myPairCurve; + Standard_Boolean myOrientation; + +}; +#endif // _StepKinematics_LinearFlexibleAndPlanarCurvePair_HeaderFile_ diff --git a/src/StepKinematics/StepKinematics_LinearFlexibleLinkRepresentation.cxx b/src/StepKinematics/StepKinematics_LinearFlexibleLinkRepresentation.cxx new file mode 100644 index 0000000000..636017e759 --- /dev/null +++ b/src/StepKinematics/StepKinematics_LinearFlexibleLinkRepresentation.cxx @@ -0,0 +1,27 @@ +// Created on : Fri May 08 19:02:07 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_LinearFlexibleLinkRepresentation, StepKinematics_KinematicLinkRepresentation) + +//======================================================================= +//function : StepKinematics_LinearFlexibleLinkRepresentation +//purpose : +//======================================================================= +StepKinematics_LinearFlexibleLinkRepresentation::StepKinematics_LinearFlexibleLinkRepresentation () +{ +} diff --git a/src/StepKinematics/StepKinematics_LinearFlexibleLinkRepresentation.hxx b/src/StepKinematics/StepKinematics_LinearFlexibleLinkRepresentation.hxx new file mode 100644 index 0000000000..de0a6c207b --- /dev/null +++ b/src/StepKinematics/StepKinematics_LinearFlexibleLinkRepresentation.hxx @@ -0,0 +1,42 @@ +// Created on : Fri May 08 19:02:07 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_LinearFlexibleLinkRepresentation_HeaderFile_ +#define _StepKinematics_LinearFlexibleLinkRepresentation_HeaderFile_ + +#include +#include +#include + +#include +#include +#include +#include + +DEFINE_STANDARD_HANDLE(StepKinematics_LinearFlexibleLinkRepresentation, StepKinematics_KinematicLinkRepresentation) + +//! Representation of STEP entity LinearFlexibleLinkRepresentation +class StepKinematics_LinearFlexibleLinkRepresentation : public StepKinematics_KinematicLinkRepresentation +{ +public : + + //! default constructor + Standard_EXPORT StepKinematics_LinearFlexibleLinkRepresentation(); + +DEFINE_STANDARD_RTTIEXT(StepKinematics_LinearFlexibleLinkRepresentation, StepKinematics_KinematicLinkRepresentation) + +}; +#endif // _StepKinematics_LinearFlexibleLinkRepresentation_HeaderFile_ diff --git a/src/StepKinematics/StepKinematics_LowOrderKinematicPair.cxx b/src/StepKinematics/StepKinematics_LowOrderKinematicPair.cxx new file mode 100644 index 0000000000..237bcd558c --- /dev/null +++ b/src/StepKinematics/StepKinematics_LowOrderKinematicPair.cxx @@ -0,0 +1,174 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..55ca99c5aa --- /dev/null +++ b/src/StepKinematics/StepKinematics_LowOrderKinematicPair.hxx @@ -0,0 +1,95 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_LowOrderKinematicPair_HeaderFile_ +#define _StepKinematics_LowOrderKinematicPair_HeaderFile_ + +#include +#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..464e4e05c5 --- /dev/null +++ b/src/StepKinematics/StepKinematics_LowOrderKinematicPairValue.cxx @@ -0,0 +1,164 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_LowOrderKinematicPairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_LowOrderKinematicPairValue +//purpose : +//======================================================================= +StepKinematics_LowOrderKinematicPairValue::StepKinematics_LowOrderKinematicPairValue () +{ +} + +//======================================================================= +//function : Init +//purpose : +//======================================================================= +void StepKinematics_LowOrderKinematicPairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Standard_Real theActualTranslationX, + const Standard_Real theActualTranslationY, + const Standard_Real theActualTranslationZ, + const Standard_Real theActualRotationX, + const Standard_Real theActualRotationY, + const Standard_Real theActualRotationZ) +{ + StepKinematics_PairValue::Init(theRepresentationItem_Name, + thePairValue_AppliesToPair); + + myActualTranslationX = theActualTranslationX; + + myActualTranslationY = theActualTranslationY; + + myActualTranslationZ = theActualTranslationZ; + + myActualRotationX = theActualRotationX; + + myActualRotationY = theActualRotationY; + + myActualRotationZ = theActualRotationZ; +} + +//======================================================================= +//function : ActualTranslationX +//purpose : +//======================================================================= +Standard_Real StepKinematics_LowOrderKinematicPairValue::ActualTranslationX () const +{ + return myActualTranslationX; +} + +//======================================================================= +//function : SetActualTranslationX +//purpose : +//======================================================================= +void StepKinematics_LowOrderKinematicPairValue::SetActualTranslationX (const Standard_Real theActualTranslationX) +{ + myActualTranslationX = theActualTranslationX; +} + +//======================================================================= +//function : ActualTranslationY +//purpose : +//======================================================================= +Standard_Real StepKinematics_LowOrderKinematicPairValue::ActualTranslationY () const +{ + return myActualTranslationY; +} + +//======================================================================= +//function : SetActualTranslationY +//purpose : +//======================================================================= +void StepKinematics_LowOrderKinematicPairValue::SetActualTranslationY (const Standard_Real theActualTranslationY) +{ + myActualTranslationY = theActualTranslationY; +} + +//======================================================================= +//function : ActualTranslationZ +//purpose : +//======================================================================= +Standard_Real StepKinematics_LowOrderKinematicPairValue::ActualTranslationZ () const +{ + return myActualTranslationZ; +} + +//======================================================================= +//function : SetActualTranslationZ +//purpose : +//======================================================================= +void StepKinematics_LowOrderKinematicPairValue::SetActualTranslationZ (const Standard_Real theActualTranslationZ) +{ + myActualTranslationZ = theActualTranslationZ; +} + +//======================================================================= +//function : ActualRotationX +//purpose : +//======================================================================= +Standard_Real StepKinematics_LowOrderKinematicPairValue::ActualRotationX () const +{ + return myActualRotationX; +} + +//======================================================================= +//function : SetActualRotationX +//purpose : +//======================================================================= +void StepKinematics_LowOrderKinematicPairValue::SetActualRotationX (const Standard_Real theActualRotationX) +{ + myActualRotationX = theActualRotationX; +} + +//======================================================================= +//function : ActualRotationY +//purpose : +//======================================================================= +Standard_Real StepKinematics_LowOrderKinematicPairValue::ActualRotationY () const +{ + return myActualRotationY; +} + +//======================================================================= +//function : SetActualRotationY +//purpose : +//======================================================================= +void StepKinematics_LowOrderKinematicPairValue::SetActualRotationY (const Standard_Real theActualRotationY) +{ + myActualRotationY = theActualRotationY; +} + +//======================================================================= +//function : ActualRotationZ +//purpose : +//======================================================================= +Standard_Real StepKinematics_LowOrderKinematicPairValue::ActualRotationZ () const +{ + return myActualRotationZ; +} + +//======================================================================= +//function : SetActualRotationZ +//purpose : +//======================================================================= +void StepKinematics_LowOrderKinematicPairValue::SetActualRotationZ (const Standard_Real theActualRotationZ) +{ + myActualRotationZ = theActualRotationZ; +} diff --git a/src/StepKinematics/StepKinematics_LowOrderKinematicPairValue.hxx b/src/StepKinematics/StepKinematics_LowOrderKinematicPairValue.hxx new file mode 100644 index 0000000000..0591a3a1d6 --- /dev/null +++ b/src/StepKinematics/StepKinematics_LowOrderKinematicPairValue.hxx @@ -0,0 +1,88 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_LowOrderKinematicPairValue_HeaderFile_ +#define _StepKinematics_LowOrderKinematicPairValue_HeaderFile_ + +#include +#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(); + + //! Initialize all fields (own and inherited) + Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Standard_Real theActualTranslationX, + const Standard_Real theActualTranslationY, + const Standard_Real theActualTranslationZ, + const Standard_Real theActualRotationX, + const Standard_Real theActualRotationY, + const Standard_Real theActualRotationZ); + + //! Returns field ActualTranslationX + Standard_EXPORT Standard_Real ActualTranslationX() const; + //! Sets field ActualTranslationX + Standard_EXPORT void SetActualTranslationX (const Standard_Real theActualTranslationX); + + //! Returns field ActualTranslationY + Standard_EXPORT Standard_Real ActualTranslationY() const; + //! Sets field ActualTranslationY + Standard_EXPORT void SetActualTranslationY (const Standard_Real theActualTranslationY); + + //! Returns field ActualTranslationZ + Standard_EXPORT Standard_Real ActualTranslationZ() const; + //! Sets field ActualTranslationZ + Standard_EXPORT void SetActualTranslationZ (const Standard_Real theActualTranslationZ); + + //! Returns field ActualRotationX + Standard_EXPORT Standard_Real ActualRotationX() const; + //! Sets field ActualRotationX + Standard_EXPORT void SetActualRotationX (const Standard_Real theActualRotationX); + + //! Returns field ActualRotationY + Standard_EXPORT Standard_Real ActualRotationY() const; + //! Sets field ActualRotationY + Standard_EXPORT void SetActualRotationY (const Standard_Real theActualRotationY); + + //! Returns field ActualRotationZ + Standard_EXPORT Standard_Real ActualRotationZ() const; + //! Sets field ActualRotationZ + Standard_EXPORT void SetActualRotationZ (const Standard_Real theActualRotationZ); + +DEFINE_STANDARD_RTTIEXT(StepKinematics_LowOrderKinematicPairValue, StepKinematics_PairValue) + +private: + Standard_Real myActualTranslationX; + Standard_Real myActualTranslationY; + Standard_Real myActualTranslationZ; + Standard_Real myActualRotationX; + Standard_Real myActualRotationY; + Standard_Real myActualRotationZ; + +}; +#endif // _StepKinematics_LowOrderKinematicPairValue_HeaderFile_ diff --git a/src/StepKinematics/StepKinematics_LowOrderKinematicPairWithMotionCoupling.cxx b/src/StepKinematics/StepKinematics_LowOrderKinematicPairWithMotionCoupling.cxx new file mode 100644 index 0000000000..1fe2071302 --- /dev/null +++ b/src/StepKinematics/StepKinematics_LowOrderKinematicPairWithMotionCoupling.cxx @@ -0,0 +1,27 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..d85ecc64fc --- /dev/null +++ b/src/StepKinematics/StepKinematics_LowOrderKinematicPairWithMotionCoupling.hxx @@ -0,0 +1,42 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_LowOrderKinematicPairWithMotionCoupling_HeaderFile_ +#define _StepKinematics_LowOrderKinematicPairWithMotionCoupling_HeaderFile_ + +#include +#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..277303707b --- /dev/null +++ b/src/StepKinematics/StepKinematics_LowOrderKinematicPairWithRange.cxx @@ -0,0 +1,492 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..f715290773 --- /dev/null +++ b/src/StepKinematics/StepKinematics_LowOrderKinematicPairWithRange.hxx @@ -0,0 +1,191 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_LowOrderKinematicPairWithRange_HeaderFile_ +#define _StepKinematics_LowOrderKinematicPairWithRange_HeaderFile_ + +#include +#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..cfa327feb9 --- /dev/null +++ b/src/StepKinematics/StepKinematics_MechanismRepresentation.cxx @@ -0,0 +1,61 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_MechanismRepresentation, StepRepr_Representation) + +//======================================================================= +//function : StepKinematics_MechanismRepresentation +//purpose : +//======================================================================= +StepKinematics_MechanismRepresentation::StepKinematics_MechanismRepresentation () +{ +} + +//======================================================================= +//function : Init +//purpose : +//======================================================================= +void StepKinematics_MechanismRepresentation::Init (const Handle(TCollection_HAsciiString)& theRepresentation_Name, + const Handle(StepRepr_HArray1OfRepresentationItem)& theRepresentation_Items, + const Handle(StepRepr_RepresentationContext)& theRepresentation_ContextOfItems, + const StepKinematics_KinematicTopologyRepresentationSelect& theRepresentedTopology) +{ + StepRepr_Representation::Init(theRepresentation_Name, + theRepresentation_Items, + theRepresentation_ContextOfItems); + + myRepresentedTopology = theRepresentedTopology; +} + +//======================================================================= +//function : RepresentedTopology +//purpose : +//======================================================================= +StepKinematics_KinematicTopologyRepresentationSelect StepKinematics_MechanismRepresentation::RepresentedTopology () const +{ + return myRepresentedTopology; +} + +//======================================================================= +//function : SetRepresentedTopology +//purpose : +//======================================================================= +void StepKinematics_MechanismRepresentation::SetRepresentedTopology (const StepKinematics_KinematicTopologyRepresentationSelect& theRepresentedTopology) +{ + myRepresentedTopology = theRepresentedTopology; +} diff --git a/src/StepKinematics/StepKinematics_MechanismRepresentation.hxx b/src/StepKinematics/StepKinematics_MechanismRepresentation.hxx new file mode 100644 index 0000000000..cfaa5823da --- /dev/null +++ b/src/StepKinematics/StepKinematics_MechanismRepresentation.hxx @@ -0,0 +1,56 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_MechanismRepresentation_HeaderFile_ +#define _StepKinematics_MechanismRepresentation_HeaderFile_ + +#include +#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(); + + //! Initialize all fields (own and inherited) + Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentation_Name, + const Handle(StepRepr_HArray1OfRepresentationItem)& theRepresentation_Items, + const Handle(StepRepr_RepresentationContext)& theRepresentation_ContextOfItems, + const StepKinematics_KinematicTopologyRepresentationSelect& theRepresentedTopology); + + //! Returns field RepresentedTopology + Standard_EXPORT StepKinematics_KinematicTopologyRepresentationSelect RepresentedTopology() const; + //! Sets field RepresentedTopology + Standard_EXPORT void SetRepresentedTopology (const StepKinematics_KinematicTopologyRepresentationSelect& theRepresentedTopology); + +DEFINE_STANDARD_RTTIEXT(StepKinematics_MechanismRepresentation, StepRepr_Representation) + +private: + StepKinematics_KinematicTopologyRepresentationSelect myRepresentedTopology; + +}; +#endif // _StepKinematics_MechanismRepresentation_HeaderFile_ diff --git a/src/StepKinematics/StepKinematics_MechanismStateRepresentation.cxx b/src/StepKinematics/StepKinematics_MechanismStateRepresentation.cxx new file mode 100644 index 0000000000..f34be4621a --- /dev/null +++ b/src/StepKinematics/StepKinematics_MechanismStateRepresentation.cxx @@ -0,0 +1,42 @@ +// Created on: 2020-06-18 +// Created by: PASUKHIN DMITRY +// Copyright (c) 2020 OPEN CASCADE SAS +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + + +#include +#include +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_MechanismStateRepresentation, StepRepr_Representation) + +StepKinematics_MechanismStateRepresentation::StepKinematics_MechanismStateRepresentation() {} + +void StepKinematics_MechanismStateRepresentation::Init(const Handle(TCollection_HAsciiString)& theName, + const Handle(StepRepr_HArray1OfRepresentationItem)& theItems, + const Handle(StepRepr_RepresentationContext)& theContextOfItems, + const Handle(StepKinematics_MechanismRepresentation) theMechanism) +{ + StepRepr_Representation::Init(theName, theItems, theContextOfItems); + myRepresentedMechanism = theMechanism; +} + +void StepKinematics_MechanismStateRepresentation::SetMechanism(const Handle(StepKinematics_MechanismRepresentation)& theMechanism) +{ + myRepresentedMechanism = theMechanism; +} + +Handle(StepKinematics_MechanismRepresentation) StepKinematics_MechanismStateRepresentation::Mechanism() const +{ + return myRepresentedMechanism; +} \ No newline at end of file diff --git a/src/StepKinematics/StepKinematics_MechanismStateRepresentation.hxx b/src/StepKinematics/StepKinematics_MechanismStateRepresentation.hxx new file mode 100644 index 0000000000..82ee1ca25c --- /dev/null +++ b/src/StepKinematics/StepKinematics_MechanismStateRepresentation.hxx @@ -0,0 +1,49 @@ +// Created on: 2020-06-18 +// Created by: PASUKHIN DMITRY +// Copyright (c) 2020 OPEN CASCADE SAS +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_MechanismStateRepresentation_HeaderFile +#define _StepKinematics_MechanismStateRepresentation_HeaderFile + +#include +#include + +#include + +class StepKinematics_MechanismRepresentation; + +class StepKinematics_MechanismStateRepresentation; +DEFINE_STANDARD_HANDLE(StepKinematics_MechanismStateRepresentation, StepRepr_Representation) + + +class StepKinematics_MechanismStateRepresentation : public StepRepr_Representation +{ +public: + + //! Returns a MechanismStateRepresentation + Standard_EXPORT StepKinematics_MechanismStateRepresentation(); + + Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theName, const Handle(StepRepr_HArray1OfRepresentationItem)& theItems, const Handle(StepRepr_RepresentationContext)& theContextOfItems, const Handle(StepKinematics_MechanismRepresentation) theMechanism); + + Standard_EXPORT void SetMechanism(const Handle(StepKinematics_MechanismRepresentation)& theMechanism); + + Standard_EXPORT Handle(StepKinematics_MechanismRepresentation) Mechanism() const; + +private: + Handle(StepKinematics_MechanismRepresentation) myRepresentedMechanism; + + DEFINE_STANDARD_RTTIEXT(StepKinematics_MechanismStateRepresentation,StepRepr_Representation) +}; + +#endif // _StepKinematics_MechanismStateRepresentation_HeaderFile diff --git a/src/StepKinematics/StepKinematics_OrientedJoint.cxx b/src/StepKinematics/StepKinematics_OrientedJoint.cxx new file mode 100644 index 0000000000..e8202b02a7 --- /dev/null +++ b/src/StepKinematics/StepKinematics_OrientedJoint.cxx @@ -0,0 +1,27 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..17ef0fe1c5 --- /dev/null +++ b/src/StepKinematics/StepKinematics_OrientedJoint.hxx @@ -0,0 +1,41 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_OrientedJoint_HeaderFile_ +#define _StepKinematics_OrientedJoint_HeaderFile_ + +#include +#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_PairRepresentationRelationship.cxx b/src/StepKinematics/StepKinematics_PairRepresentationRelationship.cxx new file mode 100644 index 0000000000..9e3710e9ef --- /dev/null +++ b/src/StepKinematics/StepKinematics_PairRepresentationRelationship.cxx @@ -0,0 +1,67 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_PairRepresentationRelationship, StepGeom_GeometricRepresentationItem) + +//======================================================================= +//function : StepKinematics_PairRepresentationRelationship +//purpose : +//======================================================================= +StepKinematics_PairRepresentationRelationship::StepKinematics_PairRepresentationRelationship () +{ +} + +//======================================================================= +//function : Init +//purpose : +//======================================================================= +void StepKinematics_PairRepresentationRelationship::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(TCollection_HAsciiString)& theRepresentationRelationship_Name, + const Standard_Boolean /*hasRepresentationRelationship_Description*/, + const Handle(TCollection_HAsciiString)& theRepresentationRelationship_Description, + const StepRepr_RepresentationOrRepresentationReference& theRepresentationRelationship_Rep1, + const StepRepr_RepresentationOrRepresentationReference& theRepresentationRelationship_Rep2, + const StepRepr_Transformation& theRepresentationRelationshipWithTransformation_TransformationOperator) +{ + StepGeom_GeometricRepresentationItem::Init(theRepresentationItem_Name); + myRepresentationRelationshipWithTransformation = new StepRepr_RepresentationRelationshipWithTransformation; + myRepresentationRelationshipWithTransformation->Init(theRepresentationRelationship_Name, + /*hasRepresentationRelationship_Description,*/ + theRepresentationRelationship_Description, + theRepresentationRelationship_Rep1.Representation(), + theRepresentationRelationship_Rep2.Representation(), + theRepresentationRelationshipWithTransformation_TransformationOperator); +} + +//======================================================================= +//function : RepresentationRelationshipWithTransformation +//purpose : +//======================================================================= +Handle(StepRepr_RepresentationRelationshipWithTransformation) StepKinematics_PairRepresentationRelationship::RepresentationRelationshipWithTransformation () const +{ + return myRepresentationRelationshipWithTransformation; +} + +//======================================================================= +//function : SetRepresentationRelationshipWithTransformation +//purpose : +//======================================================================= +void StepKinematics_PairRepresentationRelationship::SetRepresentationRelationshipWithTransformation (const Handle(StepRepr_RepresentationRelationshipWithTransformation)& theRepresentationRelationshipWithTransformation) +{ + myRepresentationRelationshipWithTransformation = theRepresentationRelationshipWithTransformation; +} diff --git a/src/StepKinematics/StepKinematics_PairRepresentationRelationship.hxx b/src/StepKinematics/StepKinematics_PairRepresentationRelationship.hxx new file mode 100644 index 0000000000..289f133a41 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PairRepresentationRelationship.hxx @@ -0,0 +1,59 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_PairRepresentationRelationship_HeaderFile_ +#define _StepKinematics_PairRepresentationRelationship_HeaderFile_ + +#include +#include +#include + +#include +#include +#include +#include + +DEFINE_STANDARD_HANDLE(StepKinematics_PairRepresentationRelationship, StepGeom_GeometricRepresentationItem) + +//! Representation of STEP entity PairRepresentationRelationship +class StepKinematics_PairRepresentationRelationship : public StepGeom_GeometricRepresentationItem +{ +public : + + //! default constructor + Standard_EXPORT StepKinematics_PairRepresentationRelationship(); + + //! Initialize all fields (own and inherited) + Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(TCollection_HAsciiString)& theRepresentationRelationship_Name, + const Standard_Boolean hasRepresentationRelationship_Description, + const Handle(TCollection_HAsciiString)& theRepresentationRelationship_Description, + const StepRepr_RepresentationOrRepresentationReference& theRepresentationRelationship_Rep1, + const StepRepr_RepresentationOrRepresentationReference& theRepresentationRelationship_Rep2, + const StepRepr_Transformation& theRepresentationRelationshipWithTransformation_TransformationOperator); + + //! Returns data for supertype RepresentationRelationshipWithTransformation + Standard_EXPORT Handle(StepRepr_RepresentationRelationshipWithTransformation) RepresentationRelationshipWithTransformation() const; + //! Sets data for supertype RepresentationRelationshipWithTransformation + Standard_EXPORT void SetRepresentationRelationshipWithTransformation (const Handle(StepRepr_RepresentationRelationshipWithTransformation)& theRepresentationRelationshipWithTransformation); + +DEFINE_STANDARD_RTTIEXT(StepKinematics_PairRepresentationRelationship, StepGeom_GeometricRepresentationItem) + +private: + Handle(StepRepr_RepresentationRelationshipWithTransformation) myRepresentationRelationshipWithTransformation; //!< supertype + +}; +#endif // _StepKinematics_PairRepresentationRelationship_HeaderFile_ diff --git a/src/StepKinematics/StepKinematics_PairValue.cxx b/src/StepKinematics/StepKinematics_PairValue.cxx new file mode 100644 index 0000000000..6c424a53f4 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PairValue.cxx @@ -0,0 +1,57 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..ec6e68391f --- /dev/null +++ b/src/StepKinematics/StepKinematics_PairValue.hxx @@ -0,0 +1,52 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_PairValue_HeaderFile_ +#define _StepKinematics_PairValue_HeaderFile_ + +#include +#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..b1b4054cab --- /dev/null +++ b/src/StepKinematics/StepKinematics_PlanarCurvePair.cxx @@ -0,0 +1,111 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..cf379d3faf --- /dev/null +++ b/src/StepKinematics/StepKinematics_PlanarCurvePair.hxx @@ -0,0 +1,75 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_PlanarCurvePair_HeaderFile_ +#define _StepKinematics_PlanarCurvePair_HeaderFile_ + +#include +#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..c9c8bad185 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PlanarCurvePairRange.cxx @@ -0,0 +1,96 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..fd7b526634 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PlanarCurvePairRange.hxx @@ -0,0 +1,72 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_PlanarCurvePairRange_HeaderFile_ +#define _StepKinematics_PlanarCurvePairRange_HeaderFile_ + +#include +#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..f469339119 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PlanarPair.cxx @@ -0,0 +1,27 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..f419fca67e --- /dev/null +++ b/src/StepKinematics/StepKinematics_PlanarPair.hxx @@ -0,0 +1,42 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_PlanarPair_HeaderFile_ +#define _StepKinematics_PlanarPair_HeaderFile_ + +#include +#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..a39d8f0494 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PlanarPairValue.cxx @@ -0,0 +1,101 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_PlanarPairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_PlanarPairValue +//purpose : +//======================================================================= +StepKinematics_PlanarPairValue::StepKinematics_PlanarPairValue () +{ +} + +//======================================================================= +//function : Init +//purpose : +//======================================================================= +void StepKinematics_PlanarPairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Standard_Real theActualRotation, + const Standard_Real theActualTranslationX, + const Standard_Real theActualTranslationY) +{ + StepKinematics_PairValue::Init(theRepresentationItem_Name, + thePairValue_AppliesToPair); + + myActualRotation = theActualRotation; + + myActualTranslationX = theActualTranslationX; + + myActualTranslationY = theActualTranslationY; +} + +//======================================================================= +//function : ActualRotation +//purpose : +//======================================================================= +Standard_Real StepKinematics_PlanarPairValue::ActualRotation () const +{ + return myActualRotation; +} + +//======================================================================= +//function : SetActualRotation +//purpose : +//======================================================================= +void StepKinematics_PlanarPairValue::SetActualRotation (const Standard_Real theActualRotation) +{ + myActualRotation = theActualRotation; +} + +//======================================================================= +//function : ActualTranslationX +//purpose : +//======================================================================= +Standard_Real StepKinematics_PlanarPairValue::ActualTranslationX () const +{ + return myActualTranslationX; +} + +//======================================================================= +//function : SetActualTranslationX +//purpose : +//======================================================================= +void StepKinematics_PlanarPairValue::SetActualTranslationX (const Standard_Real theActualTranslationX) +{ + myActualTranslationX = theActualTranslationX; +} + +//======================================================================= +//function : ActualTranslationY +//purpose : +//======================================================================= +Standard_Real StepKinematics_PlanarPairValue::ActualTranslationY () const +{ + return myActualTranslationY; +} + +//======================================================================= +//function : SetActualTranslationY +//purpose : +//======================================================================= +void StepKinematics_PlanarPairValue::SetActualTranslationY (const Standard_Real theActualTranslationY) +{ + myActualTranslationY = theActualTranslationY; +} diff --git a/src/StepKinematics/StepKinematics_PlanarPairValue.hxx b/src/StepKinematics/StepKinematics_PlanarPairValue.hxx new file mode 100644 index 0000000000..87c682a769 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PlanarPairValue.hxx @@ -0,0 +1,67 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_PlanarPairValue_HeaderFile_ +#define _StepKinematics_PlanarPairValue_HeaderFile_ + +#include +#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(); + + //! Initialize all fields (own and inherited) + Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Standard_Real theActualRotation, + const Standard_Real theActualTranslationX, + const Standard_Real theActualTranslationY); + + //! Returns field ActualRotation + Standard_EXPORT Standard_Real ActualRotation() const; + //! Sets field ActualRotation + Standard_EXPORT void SetActualRotation (const Standard_Real theActualRotation); + + //! Returns field ActualTranslationX + Standard_EXPORT Standard_Real ActualTranslationX() const; + //! Sets field ActualTranslationX + Standard_EXPORT void SetActualTranslationX (const Standard_Real theActualTranslationX); + + //! Returns field ActualTranslationY + Standard_EXPORT Standard_Real ActualTranslationY() const; + //! Sets field ActualTranslationY + Standard_EXPORT void SetActualTranslationY (const Standard_Real theActualTranslationY); + +DEFINE_STANDARD_RTTIEXT(StepKinematics_PlanarPairValue, StepKinematics_PairValue) + +private: + Standard_Real myActualRotation; + Standard_Real myActualTranslationX; + Standard_Real myActualTranslationY; + +}; +#endif // _StepKinematics_PlanarPairValue_HeaderFile_ diff --git a/src/StepKinematics/StepKinematics_PlanarPairWithRange.cxx b/src/StepKinematics/StepKinematics_PlanarPairWithRange.cxx new file mode 100644 index 0000000000..3328a4a0ee --- /dev/null +++ b/src/StepKinematics/StepKinematics_PlanarPairWithRange.cxx @@ -0,0 +1,276 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..c7e9e9e0c7 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PlanarPairWithRange.hxx @@ -0,0 +1,125 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_PlanarPairWithRange_HeaderFile_ +#define _StepKinematics_PlanarPairWithRange_HeaderFile_ + +#include +#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..374a3e373c --- /dev/null +++ b/src/StepKinematics/StepKinematics_PointOnPlanarCurvePair.cxx @@ -0,0 +1,90 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..c01368abf2 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PointOnPlanarCurvePair.hxx @@ -0,0 +1,68 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_PointOnPlanarCurvePair_HeaderFile_ +#define _StepKinematics_PointOnPlanarCurvePair_HeaderFile_ + +#include +#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..32732cf39b --- /dev/null +++ b/src/StepKinematics/StepKinematics_PointOnPlanarCurvePairValue.cxx @@ -0,0 +1,80 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_PointOnPlanarCurvePairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_PointOnPlanarCurvePairValue +//purpose : +//======================================================================= +StepKinematics_PointOnPlanarCurvePairValue::StepKinematics_PointOnPlanarCurvePairValue () +{ +} + +//======================================================================= +//function : Init +//purpose : +//======================================================================= +void StepKinematics_PointOnPlanarCurvePairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve, + const StepKinematics_SpatialRotation& theInputOrientation) +{ + StepKinematics_PairValue::Init(theRepresentationItem_Name, + thePairValue_AppliesToPair); + + myActualPointOnCurve = theActualPointOnCurve; + + myInputOrientation = theInputOrientation; +} + +//======================================================================= +//function : ActualPointOnCurve +//purpose : +//======================================================================= +Handle(StepGeom_PointOnCurve) StepKinematics_PointOnPlanarCurvePairValue::ActualPointOnCurve () const +{ + return myActualPointOnCurve; +} + +//======================================================================= +//function : SetActualPointOnCurve +//purpose : +//======================================================================= +void StepKinematics_PointOnPlanarCurvePairValue::SetActualPointOnCurve (const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve) +{ + myActualPointOnCurve = theActualPointOnCurve; +} + +//======================================================================= +//function : InputOrientation +//purpose : +//======================================================================= +StepKinematics_SpatialRotation StepKinematics_PointOnPlanarCurvePairValue::InputOrientation () const +{ + return myInputOrientation; +} + +//======================================================================= +//function : SetInputOrientation +//purpose : +//======================================================================= +void StepKinematics_PointOnPlanarCurvePairValue::SetInputOrientation (const StepKinematics_SpatialRotation& theInputOrientation) +{ + myInputOrientation = theInputOrientation; +} diff --git a/src/StepKinematics/StepKinematics_PointOnPlanarCurvePairValue.hxx b/src/StepKinematics/StepKinematics_PointOnPlanarCurvePairValue.hxx new file mode 100644 index 0000000000..264620b623 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PointOnPlanarCurvePairValue.hxx @@ -0,0 +1,62 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_PointOnPlanarCurvePairValue_HeaderFile_ +#define _StepKinematics_PointOnPlanarCurvePairValue_HeaderFile_ + +#include +#include +#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(); + + //! Initialize all fields (own and inherited) + Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve, + const StepKinematics_SpatialRotation& theInputOrientation); + + //! Returns field ActualPointOnCurve + Standard_EXPORT Handle(StepGeom_PointOnCurve) ActualPointOnCurve() const; + //! Sets field ActualPointOnCurve + Standard_EXPORT void SetActualPointOnCurve (const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve); + + //! Returns field InputOrientation + Standard_EXPORT StepKinematics_SpatialRotation InputOrientation() const; + //! Sets field InputOrientation + Standard_EXPORT void SetInputOrientation (const StepKinematics_SpatialRotation& theInputOrientation); + +DEFINE_STANDARD_RTTIEXT(StepKinematics_PointOnPlanarCurvePairValue, StepKinematics_PairValue) + +private: + Handle(StepGeom_PointOnCurve) myActualPointOnCurve; + StepKinematics_SpatialRotation myInputOrientation; + +}; +#endif // _StepKinematics_PointOnPlanarCurvePairValue_HeaderFile_ diff --git a/src/StepKinematics/StepKinematics_PointOnPlanarCurvePairWithRange.cxx b/src/StepKinematics/StepKinematics_PointOnPlanarCurvePairWithRange.cxx new file mode 100644 index 0000000000..e6027ad144 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PointOnPlanarCurvePairWithRange.cxx @@ -0,0 +1,289 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..0289cfe040 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PointOnPlanarCurvePairWithRange.hxx @@ -0,0 +1,130 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_PointOnPlanarCurvePairWithRange_HeaderFile_ +#define _StepKinematics_PointOnPlanarCurvePairWithRange_HeaderFile_ + +#include +#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..9809478aab --- /dev/null +++ b/src/StepKinematics/StepKinematics_PointOnSurfacePair.cxx @@ -0,0 +1,69 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..b54396e3c8 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PointOnSurfacePair.hxx @@ -0,0 +1,61 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_PointOnSurfacePair_HeaderFile_ +#define _StepKinematics_PointOnSurfacePair_HeaderFile_ + +#include +#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..81e7308a05 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PointOnSurfacePairValue.cxx @@ -0,0 +1,80 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_PointOnSurfacePairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_PointOnSurfacePairValue +//purpose : +//======================================================================= +StepKinematics_PointOnSurfacePairValue::StepKinematics_PointOnSurfacePairValue () +{ +} + +//======================================================================= +//function : Init +//purpose : +//======================================================================= +void StepKinematics_PointOnSurfacePairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface, + const StepKinematics_SpatialRotation& theInputOrientation) +{ + StepKinematics_PairValue::Init(theRepresentationItem_Name, + thePairValue_AppliesToPair); + + myActualPointOnSurface = theActualPointOnSurface; + + myInputOrientation = theInputOrientation; +} + +//======================================================================= +//function : ActualPointOnSurface +//purpose : +//======================================================================= +Handle(StepGeom_PointOnSurface) StepKinematics_PointOnSurfacePairValue::ActualPointOnSurface () const +{ + return myActualPointOnSurface; +} + +//======================================================================= +//function : SetActualPointOnSurface +//purpose : +//======================================================================= +void StepKinematics_PointOnSurfacePairValue::SetActualPointOnSurface (const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface) +{ + myActualPointOnSurface = theActualPointOnSurface; +} + +//======================================================================= +//function : InputOrientation +//purpose : +//======================================================================= +StepKinematics_SpatialRotation StepKinematics_PointOnSurfacePairValue::InputOrientation () const +{ + return myInputOrientation; +} + +//======================================================================= +//function : SetInputOrientation +//purpose : +//======================================================================= +void StepKinematics_PointOnSurfacePairValue::SetInputOrientation (const StepKinematics_SpatialRotation& theInputOrientation) +{ + myInputOrientation = theInputOrientation; +} diff --git a/src/StepKinematics/StepKinematics_PointOnSurfacePairValue.hxx b/src/StepKinematics/StepKinematics_PointOnSurfacePairValue.hxx new file mode 100644 index 0000000000..68a3396e1c --- /dev/null +++ b/src/StepKinematics/StepKinematics_PointOnSurfacePairValue.hxx @@ -0,0 +1,62 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_PointOnSurfacePairValue_HeaderFile_ +#define _StepKinematics_PointOnSurfacePairValue_HeaderFile_ + +#include +#include +#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(); + + //! Initialize all fields (own and inherited) + Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface, + const StepKinematics_SpatialRotation& theInputOrientation); + + //! Returns field ActualPointOnSurface + Standard_EXPORT Handle(StepGeom_PointOnSurface) ActualPointOnSurface() const; + //! Sets field ActualPointOnSurface + Standard_EXPORT void SetActualPointOnSurface (const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface); + + //! Returns field InputOrientation + Standard_EXPORT StepKinematics_SpatialRotation InputOrientation() const; + //! Sets field InputOrientation + Standard_EXPORT void SetInputOrientation (const StepKinematics_SpatialRotation& theInputOrientation); + +DEFINE_STANDARD_RTTIEXT(StepKinematics_PointOnSurfacePairValue, StepKinematics_PairValue) + +private: + Handle(StepGeom_PointOnSurface) myActualPointOnSurface; + StepKinematics_SpatialRotation myInputOrientation; + +}; +#endif // _StepKinematics_PointOnSurfacePairValue_HeaderFile_ diff --git a/src/StepKinematics/StepKinematics_PointOnSurfacePairWithRange.cxx b/src/StepKinematics/StepKinematics_PointOnSurfacePairWithRange.cxx new file mode 100644 index 0000000000..74d76a7af2 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PointOnSurfacePairWithRange.cxx @@ -0,0 +1,287 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..390f0ba9f4 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PointOnSurfacePairWithRange.hxx @@ -0,0 +1,129 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_PointOnSurfacePairWithRange_HeaderFile_ +#define _StepKinematics_PointOnSurfacePairWithRange_HeaderFile_ + +#include +#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..6f200884a2 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PrismaticPair.cxx @@ -0,0 +1,27 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..5fd51446f3 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PrismaticPair.hxx @@ -0,0 +1,42 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_PrismaticPair_HeaderFile_ +#define _StepKinematics_PrismaticPair_HeaderFile_ + +#include +#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..97aab12399 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PrismaticPairValue.cxx @@ -0,0 +1,59 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_PrismaticPairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_PrismaticPairValue +//purpose : +//======================================================================= +StepKinematics_PrismaticPairValue::StepKinematics_PrismaticPairValue () +{ +} + +//======================================================================= +//function : Init +//purpose : +//======================================================================= +void StepKinematics_PrismaticPairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Standard_Real theActualTranslation) +{ + StepKinematics_PairValue::Init(theRepresentationItem_Name, + thePairValue_AppliesToPair); + + myActualTranslation = theActualTranslation; +} + +//======================================================================= +//function : ActualTranslation +//purpose : +//======================================================================= +Standard_Real StepKinematics_PrismaticPairValue::ActualTranslation () const +{ + return myActualTranslation; +} + +//======================================================================= +//function : SetActualTranslation +//purpose : +//======================================================================= +void StepKinematics_PrismaticPairValue::SetActualTranslation (const Standard_Real theActualTranslation) +{ + myActualTranslation = theActualTranslation; +} diff --git a/src/StepKinematics/StepKinematics_PrismaticPairValue.hxx b/src/StepKinematics/StepKinematics_PrismaticPairValue.hxx new file mode 100644 index 0000000000..758288a6ad --- /dev/null +++ b/src/StepKinematics/StepKinematics_PrismaticPairValue.hxx @@ -0,0 +1,53 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_PrismaticPairValue_HeaderFile_ +#define _StepKinematics_PrismaticPairValue_HeaderFile_ + +#include +#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(); + + //! Initialize all fields (own and inherited) + Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Standard_Real theActualTranslation); + + //! Returns field ActualTranslation + Standard_EXPORT Standard_Real ActualTranslation() const; + //! Sets field ActualTranslation + Standard_EXPORT void SetActualTranslation (const Standard_Real theActualTranslation); + +DEFINE_STANDARD_RTTIEXT(StepKinematics_PrismaticPairValue, StepKinematics_PairValue) + +private: + Standard_Real myActualTranslation; + +}; +#endif // _StepKinematics_PrismaticPairValue_HeaderFile_ diff --git a/src/StepKinematics/StepKinematics_PrismaticPairWithRange.cxx b/src/StepKinematics/StepKinematics_PrismaticPairWithRange.cxx new file mode 100644 index 0000000000..84f058ae48 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PrismaticPairWithRange.cxx @@ -0,0 +1,132 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..11bb017f28 --- /dev/null +++ b/src/StepKinematics/StepKinematics_PrismaticPairWithRange.hxx @@ -0,0 +1,81 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_PrismaticPairWithRange_HeaderFile_ +#define _StepKinematics_PrismaticPairWithRange_HeaderFile_ + +#include +#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..1bbd6b23a5 --- /dev/null +++ b/src/StepKinematics/StepKinematics_ProductDefinitionKinematics.cxx @@ -0,0 +1,27 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..ed1078166f --- /dev/null +++ b/src/StepKinematics/StepKinematics_ProductDefinitionKinematics.hxx @@ -0,0 +1,40 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_ProductDefinitionKinematics_HeaderFile_ +#define _StepKinematics_ProductDefinitionKinematics_HeaderFile_ + +#include +#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..ffdae3daf0 --- /dev/null +++ b/src/StepKinematics/StepKinematics_ProductDefinitionRelationshipKinematics.cxx @@ -0,0 +1,27 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..1c4717e54c --- /dev/null +++ b/src/StepKinematics/StepKinematics_ProductDefinitionRelationshipKinematics.hxx @@ -0,0 +1,40 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_ProductDefinitionRelationshipKinematics_HeaderFile_ +#define _StepKinematics_ProductDefinitionRelationshipKinematics_HeaderFile_ + +#include +#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..3a1fccb407 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RackAndPinionPair.cxx @@ -0,0 +1,69 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..35e0996685 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RackAndPinionPair.hxx @@ -0,0 +1,60 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_RackAndPinionPair_HeaderFile_ +#define _StepKinematics_RackAndPinionPair_HeaderFile_ + +#include +#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..fb20fb523f --- /dev/null +++ b/src/StepKinematics/StepKinematics_RackAndPinionPairValue.cxx @@ -0,0 +1,59 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_RackAndPinionPairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_RackAndPinionPairValue +//purpose : +//======================================================================= +StepKinematics_RackAndPinionPairValue::StepKinematics_RackAndPinionPairValue () +{ +} + +//======================================================================= +//function : Init +//purpose : +//======================================================================= +void StepKinematics_RackAndPinionPairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Standard_Real theActualDisplacement) +{ + StepKinematics_PairValue::Init(theRepresentationItem_Name, + thePairValue_AppliesToPair); + + myActualDisplacement = theActualDisplacement; +} + +//======================================================================= +//function : ActualDisplacement +//purpose : +//======================================================================= +Standard_Real StepKinematics_RackAndPinionPairValue::ActualDisplacement () const +{ + return myActualDisplacement; +} + +//======================================================================= +//function : SetActualDisplacement +//purpose : +//======================================================================= +void StepKinematics_RackAndPinionPairValue::SetActualDisplacement (const Standard_Real theActualDisplacement) +{ + myActualDisplacement = theActualDisplacement; +} diff --git a/src/StepKinematics/StepKinematics_RackAndPinionPairValue.hxx b/src/StepKinematics/StepKinematics_RackAndPinionPairValue.hxx new file mode 100644 index 0000000000..695caceb5b --- /dev/null +++ b/src/StepKinematics/StepKinematics_RackAndPinionPairValue.hxx @@ -0,0 +1,53 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_RackAndPinionPairValue_HeaderFile_ +#define _StepKinematics_RackAndPinionPairValue_HeaderFile_ + +#include +#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(); + + //! Initialize all fields (own and inherited) + Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Standard_Real theActualDisplacement); + + //! Returns field ActualDisplacement + Standard_EXPORT Standard_Real ActualDisplacement() const; + //! Sets field ActualDisplacement + Standard_EXPORT void SetActualDisplacement (const Standard_Real theActualDisplacement); + +DEFINE_STANDARD_RTTIEXT(StepKinematics_RackAndPinionPairValue, StepKinematics_PairValue) + +private: + Standard_Real myActualDisplacement; + +}; +#endif // _StepKinematics_RackAndPinionPairValue_HeaderFile_ diff --git a/src/StepKinematics/StepKinematics_RackAndPinionPairWithRange.cxx b/src/StepKinematics/StepKinematics_RackAndPinionPairWithRange.cxx new file mode 100644 index 0000000000..ddae649746 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RackAndPinionPairWithRange.cxx @@ -0,0 +1,122 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..356a0ff038 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RackAndPinionPairWithRange.hxx @@ -0,0 +1,76 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_RackAndPinionPairWithRange_HeaderFile_ +#define _StepKinematics_RackAndPinionPairWithRange_HeaderFile_ + +#include +#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..17b17b7730 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RevolutePair.cxx @@ -0,0 +1,27 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..58da2eecbb --- /dev/null +++ b/src/StepKinematics/StepKinematics_RevolutePair.hxx @@ -0,0 +1,42 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_RevolutePair_HeaderFile_ +#define _StepKinematics_RevolutePair_HeaderFile_ + +#include +#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..b1c61fd8d4 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RevolutePairValue.cxx @@ -0,0 +1,59 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_RevolutePairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_RevolutePairValue +//purpose : +//======================================================================= +StepKinematics_RevolutePairValue::StepKinematics_RevolutePairValue () +{ +} + +//======================================================================= +//function : Init +//purpose : +//======================================================================= +void StepKinematics_RevolutePairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Standard_Real theActualRotation) +{ + StepKinematics_PairValue::Init(theRepresentationItem_Name, + thePairValue_AppliesToPair); + + myActualRotation = theActualRotation; +} + +//======================================================================= +//function : ActualRotation +//purpose : +//======================================================================= +Standard_Real StepKinematics_RevolutePairValue::ActualRotation () const +{ + return myActualRotation; +} + +//======================================================================= +//function : SetActualRotation +//purpose : +//======================================================================= +void StepKinematics_RevolutePairValue::SetActualRotation (const Standard_Real theActualRotation) +{ + myActualRotation = theActualRotation; +} diff --git a/src/StepKinematics/StepKinematics_RevolutePairValue.hxx b/src/StepKinematics/StepKinematics_RevolutePairValue.hxx new file mode 100644 index 0000000000..eb261a1b96 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RevolutePairValue.hxx @@ -0,0 +1,53 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_RevolutePairValue_HeaderFile_ +#define _StepKinematics_RevolutePairValue_HeaderFile_ + +#include +#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(); + + //! Initialize all fields (own and inherited) + Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Standard_Real theActualRotation); + + //! Returns field ActualRotation + Standard_EXPORT Standard_Real ActualRotation() const; + //! Sets field ActualRotation + Standard_EXPORT void SetActualRotation (const Standard_Real theActualRotation); + +DEFINE_STANDARD_RTTIEXT(StepKinematics_RevolutePairValue, StepKinematics_PairValue) + +private: + Standard_Real myActualRotation; + +}; +#endif // _StepKinematics_RevolutePairValue_HeaderFile_ diff --git a/src/StepKinematics/StepKinematics_RevolutePairWithRange.cxx b/src/StepKinematics/StepKinematics_RevolutePairWithRange.cxx new file mode 100644 index 0000000000..db06b53bff --- /dev/null +++ b/src/StepKinematics/StepKinematics_RevolutePairWithRange.cxx @@ -0,0 +1,132 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..93a25592ab --- /dev/null +++ b/src/StepKinematics/StepKinematics_RevolutePairWithRange.hxx @@ -0,0 +1,81 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_RevolutePairWithRange_HeaderFile_ +#define _StepKinematics_RevolutePairWithRange_HeaderFile_ + +#include +#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_RigidLinkRepresentation.cxx b/src/StepKinematics/StepKinematics_RigidLinkRepresentation.cxx new file mode 100644 index 0000000000..654b26b4e3 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RigidLinkRepresentation.cxx @@ -0,0 +1,27 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_RigidLinkRepresentation, StepKinematics_KinematicLinkRepresentation) + +//======================================================================= +//function : StepKinematics_RigidLinkRepresentation +//purpose : +//======================================================================= +StepKinematics_RigidLinkRepresentation::StepKinematics_RigidLinkRepresentation () +{ +} diff --git a/src/StepKinematics/StepKinematics_RigidLinkRepresentation.hxx b/src/StepKinematics/StepKinematics_RigidLinkRepresentation.hxx new file mode 100644 index 0000000000..abae00ea4e --- /dev/null +++ b/src/StepKinematics/StepKinematics_RigidLinkRepresentation.hxx @@ -0,0 +1,42 @@ +// Created on : Sat May 02 12:41:15 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_RigidLinkRepresentation_HeaderFile_ +#define _StepKinematics_RigidLinkRepresentation_HeaderFile_ + +#include +#include +#include + +#include +#include +#include +#include + +DEFINE_STANDARD_HANDLE(StepKinematics_RigidLinkRepresentation, StepKinematics_KinematicLinkRepresentation) + +//! Representation of STEP entity RigidLinkRepresentation +class StepKinematics_RigidLinkRepresentation : public StepKinematics_KinematicLinkRepresentation +{ +public : + + //! default constructor + Standard_EXPORT StepKinematics_RigidLinkRepresentation(); + +DEFINE_STANDARD_RTTIEXT(StepKinematics_RigidLinkRepresentation, StepKinematics_KinematicLinkRepresentation) + +}; +#endif // _StepKinematics_RigidLinkRepresentation_HeaderFile_ diff --git a/src/StepKinematics/StepKinematics_RigidPlacement.cxx b/src/StepKinematics/StepKinematics_RigidPlacement.cxx new file mode 100644 index 0000000000..b89f56d0f8 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RigidPlacement.cxx @@ -0,0 +1,57 @@ +// Created on : Sat May 02 12:41:14 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include +#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(StepGeom_SuParameters))) return 2; + return 0; +} + +//======================================================================= +//function : Axis2Placement3d +//purpose : +//======================================================================= +Handle(StepGeom_Axis2Placement3d) StepKinematics_RigidPlacement::Axis2Placement3d () const +{ + return Handle(StepGeom_Axis2Placement3d)::DownCast(Value()); +} + +//======================================================================= +//function : SuParameters +//purpose : +//======================================================================= +Handle(StepGeom_SuParameters) StepKinematics_RigidPlacement::SuParameters () const +{ + return Handle(StepGeom_SuParameters)::DownCast(Value()); +} diff --git a/src/StepKinematics/StepKinematics_RigidPlacement.hxx b/src/StepKinematics/StepKinematics_RigidPlacement.hxx new file mode 100644 index 0000000000..74a7a08a86 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RigidPlacement.hxx @@ -0,0 +1,53 @@ +// Created on : Sat May 02 12:41:14 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_RigidPlacement_HeaderFile +#define _StepKinematics_RigidPlacement_HeaderFile + +#include +#include +#include +#include +#include + +class Standard_Transient; +class StepGeom_Axis2Placement3d; +class StepGeom_SuParameters; + +//! Representation of STEP SELECT type RigidPlacement +class StepKinematics_RigidPlacement : public StepData_SelectType +{ + +public: + + DEFINE_STANDARD_ALLOC + + //! Empty constructor + Standard_EXPORT StepKinematics_RigidPlacement(); + + //! Recognizes a kind of RigidPlacement select type + //! -- 1 -> Axis2Placement3d + //! -- 2 -> SuParameters + Standard_EXPORT Standard_Integer CaseNum (const Handle(Standard_Transient)& ent) const Standard_OVERRIDE; + + //! Returns Value as Axis2Placement3d (or Null if another type) + Standard_EXPORT Handle(StepGeom_Axis2Placement3d) Axis2Placement3d() const; + + //! Returns Value as SuParameters (or Null if another type) + Standard_EXPORT Handle(StepGeom_SuParameters) SuParameters() const; + +}; +#endif // _StepKinematics_RigidPlacement_HeaderFile diff --git a/src/StepKinematics/StepKinematics_RollingCurvePair.cxx b/src/StepKinematics/StepKinematics_RollingCurvePair.cxx new file mode 100644 index 0000000000..9c6ea96239 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RollingCurvePair.cxx @@ -0,0 +1,27 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..e839cfe602 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RollingCurvePair.hxx @@ -0,0 +1,43 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_RollingCurvePair_HeaderFile_ +#define _StepKinematics_RollingCurvePair_HeaderFile_ + +#include +#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..330bc77c92 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RollingCurvePairValue.cxx @@ -0,0 +1,59 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_RollingCurvePairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_RollingCurvePairValue +//purpose : +//======================================================================= +StepKinematics_RollingCurvePairValue::StepKinematics_RollingCurvePairValue () +{ +} + +//======================================================================= +//function : Init +//purpose : +//======================================================================= +void StepKinematics_RollingCurvePairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve1) +{ + StepKinematics_PairValue::Init(theRepresentationItem_Name, + thePairValue_AppliesToPair); + + myActualPointOnCurve1 = theActualPointOnCurve1; +} + +//======================================================================= +//function : ActualPointOnCurve1 +//purpose : +//======================================================================= +Handle(StepGeom_PointOnCurve) StepKinematics_RollingCurvePairValue::ActualPointOnCurve1 () const +{ + return myActualPointOnCurve1; +} + +//======================================================================= +//function : SetActualPointOnCurve1 +//purpose : +//======================================================================= +void StepKinematics_RollingCurvePairValue::SetActualPointOnCurve1 (const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve1) +{ + myActualPointOnCurve1 = theActualPointOnCurve1; +} diff --git a/src/StepKinematics/StepKinematics_RollingCurvePairValue.hxx b/src/StepKinematics/StepKinematics_RollingCurvePairValue.hxx new file mode 100644 index 0000000000..c00671da3b --- /dev/null +++ b/src/StepKinematics/StepKinematics_RollingCurvePairValue.hxx @@ -0,0 +1,54 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_RollingCurvePairValue_HeaderFile_ +#define _StepKinematics_RollingCurvePairValue_HeaderFile_ + +#include +#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(); + + //! Initialize all fields (own and inherited) + Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve1); + + //! Returns field ActualPointOnCurve1 + Standard_EXPORT Handle(StepGeom_PointOnCurve) ActualPointOnCurve1() const; + //! Sets field ActualPointOnCurve1 + Standard_EXPORT void SetActualPointOnCurve1 (const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve1); + +DEFINE_STANDARD_RTTIEXT(StepKinematics_RollingCurvePairValue, StepKinematics_PairValue) + +private: + Handle(StepGeom_PointOnCurve) myActualPointOnCurve1; + +}; +#endif // _StepKinematics_RollingCurvePairValue_HeaderFile_ diff --git a/src/StepKinematics/StepKinematics_RollingSurfacePair.cxx b/src/StepKinematics/StepKinematics_RollingSurfacePair.cxx new file mode 100644 index 0000000000..373623ad68 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RollingSurfacePair.cxx @@ -0,0 +1,27 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..6a389c7ff1 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RollingSurfacePair.hxx @@ -0,0 +1,43 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_RollingSurfacePair_HeaderFile_ +#define _StepKinematics_RollingSurfacePair_HeaderFile_ + +#include +#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..5a74cf0281 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RollingSurfacePairValue.cxx @@ -0,0 +1,80 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_RollingSurfacePairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_RollingSurfacePairValue +//purpose : +//======================================================================= +StepKinematics_RollingSurfacePairValue::StepKinematics_RollingSurfacePairValue () +{ +} + +//======================================================================= +//function : Init +//purpose : +//======================================================================= +void StepKinematics_RollingSurfacePairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface, + const Standard_Real theActualRotation) +{ + StepKinematics_PairValue::Init(theRepresentationItem_Name, + thePairValue_AppliesToPair); + + myActualPointOnSurface = theActualPointOnSurface; + + myActualRotation = theActualRotation; +} + +//======================================================================= +//function : ActualPointOnSurface +//purpose : +//======================================================================= +Handle(StepGeom_PointOnSurface) StepKinematics_RollingSurfacePairValue::ActualPointOnSurface () const +{ + return myActualPointOnSurface; +} + +//======================================================================= +//function : SetActualPointOnSurface +//purpose : +//======================================================================= +void StepKinematics_RollingSurfacePairValue::SetActualPointOnSurface (const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface) +{ + myActualPointOnSurface = theActualPointOnSurface; +} + +//======================================================================= +//function : ActualRotation +//purpose : +//======================================================================= +Standard_Real StepKinematics_RollingSurfacePairValue::ActualRotation () const +{ + return myActualRotation; +} + +//======================================================================= +//function : SetActualRotation +//purpose : +//======================================================================= +void StepKinematics_RollingSurfacePairValue::SetActualRotation (const Standard_Real theActualRotation) +{ + myActualRotation = theActualRotation; +} diff --git a/src/StepKinematics/StepKinematics_RollingSurfacePairValue.hxx b/src/StepKinematics/StepKinematics_RollingSurfacePairValue.hxx new file mode 100644 index 0000000000..ab7ef66bc4 --- /dev/null +++ b/src/StepKinematics/StepKinematics_RollingSurfacePairValue.hxx @@ -0,0 +1,61 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_RollingSurfacePairValue_HeaderFile_ +#define _StepKinematics_RollingSurfacePairValue_HeaderFile_ + +#include +#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(); + + //! Initialize all fields (own and inherited) + Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface, + const Standard_Real theActualRotation); + + //! Returns field ActualPointOnSurface + Standard_EXPORT Handle(StepGeom_PointOnSurface) ActualPointOnSurface() const; + //! Sets field ActualPointOnSurface + Standard_EXPORT void SetActualPointOnSurface (const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface); + + //! Returns field ActualRotation + Standard_EXPORT Standard_Real ActualRotation() const; + //! Sets field ActualRotation + Standard_EXPORT void SetActualRotation (const Standard_Real theActualRotation); + +DEFINE_STANDARD_RTTIEXT(StepKinematics_RollingSurfacePairValue, StepKinematics_PairValue) + +private: + Handle(StepGeom_PointOnSurface) myActualPointOnSurface; + Standard_Real myActualRotation; + +}; +#endif // _StepKinematics_RollingSurfacePairValue_HeaderFile_ diff --git a/src/StepKinematics/StepKinematics_RotationAboutDirection.cxx b/src/StepKinematics/StepKinematics_RotationAboutDirection.cxx new file mode 100644 index 0000000000..5df13f9a9e --- /dev/null +++ b/src/StepKinematics/StepKinematics_RotationAboutDirection.cxx @@ -0,0 +1,78 @@ +// Created on : Sat May 02 12:41:14 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..54e82408fd --- /dev/null +++ b/src/StepKinematics/StepKinematics_RotationAboutDirection.hxx @@ -0,0 +1,59 @@ +// Created on : Sat May 02 12:41:14 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_RotationAboutDirection_HeaderFile_ +#define _StepKinematics_RotationAboutDirection_HeaderFile_ + +#include +#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..f666506988 --- /dev/null +++ b/src/StepKinematics/StepKinematics_ScrewPair.cxx @@ -0,0 +1,69 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..ddc6be1e9c --- /dev/null +++ b/src/StepKinematics/StepKinematics_ScrewPair.hxx @@ -0,0 +1,60 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_ScrewPair_HeaderFile_ +#define _StepKinematics_ScrewPair_HeaderFile_ + +#include +#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..58a3a8cea9 --- /dev/null +++ b/src/StepKinematics/StepKinematics_ScrewPairValue.cxx @@ -0,0 +1,59 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_ScrewPairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_ScrewPairValue +//purpose : +//======================================================================= +StepKinematics_ScrewPairValue::StepKinematics_ScrewPairValue () +{ +} + +//======================================================================= +//function : Init +//purpose : +//======================================================================= +void StepKinematics_ScrewPairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Standard_Real theActualRotation) +{ + StepKinematics_PairValue::Init(theRepresentationItem_Name, + thePairValue_AppliesToPair); + + myActualRotation = theActualRotation; +} + +//======================================================================= +//function : ActualRotation +//purpose : +//======================================================================= +Standard_Real StepKinematics_ScrewPairValue::ActualRotation () const +{ + return myActualRotation; +} + +//======================================================================= +//function : SetActualRotation +//purpose : +//======================================================================= +void StepKinematics_ScrewPairValue::SetActualRotation (const Standard_Real theActualRotation) +{ + myActualRotation = theActualRotation; +} diff --git a/src/StepKinematics/StepKinematics_ScrewPairValue.hxx b/src/StepKinematics/StepKinematics_ScrewPairValue.hxx new file mode 100644 index 0000000000..eb90500321 --- /dev/null +++ b/src/StepKinematics/StepKinematics_ScrewPairValue.hxx @@ -0,0 +1,53 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_ScrewPairValue_HeaderFile_ +#define _StepKinematics_ScrewPairValue_HeaderFile_ + +#include +#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(); + + //! Initialize all fields (own and inherited) + Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Standard_Real theActualRotation); + + //! Returns field ActualRotation + Standard_EXPORT Standard_Real ActualRotation() const; + //! Sets field ActualRotation + Standard_EXPORT void SetActualRotation (const Standard_Real theActualRotation); + +DEFINE_STANDARD_RTTIEXT(StepKinematics_ScrewPairValue, StepKinematics_PairValue) + +private: + Standard_Real myActualRotation; + +}; +#endif // _StepKinematics_ScrewPairValue_HeaderFile_ diff --git a/src/StepKinematics/StepKinematics_ScrewPairWithRange.cxx b/src/StepKinematics/StepKinematics_ScrewPairWithRange.cxx new file mode 100644 index 0000000000..200d4b9fe2 --- /dev/null +++ b/src/StepKinematics/StepKinematics_ScrewPairWithRange.cxx @@ -0,0 +1,122 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..da227fa427 --- /dev/null +++ b/src/StepKinematics/StepKinematics_ScrewPairWithRange.hxx @@ -0,0 +1,76 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_ScrewPairWithRange_HeaderFile_ +#define _StepKinematics_ScrewPairWithRange_HeaderFile_ + +#include +#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..063f3eb0f7 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SlidingCurvePair.cxx @@ -0,0 +1,27 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..93d6112e01 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SlidingCurvePair.hxx @@ -0,0 +1,43 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_SlidingCurvePair_HeaderFile_ +#define _StepKinematics_SlidingCurvePair_HeaderFile_ + +#include +#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..82599fd37d --- /dev/null +++ b/src/StepKinematics/StepKinematics_SlidingCurvePairValue.cxx @@ -0,0 +1,80 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_SlidingCurvePairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_SlidingCurvePairValue +//purpose : +//======================================================================= +StepKinematics_SlidingCurvePairValue::StepKinematics_SlidingCurvePairValue () +{ +} + +//======================================================================= +//function : Init +//purpose : +//======================================================================= +void StepKinematics_SlidingCurvePairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve1, + const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve2) +{ + StepKinematics_PairValue::Init(theRepresentationItem_Name, + thePairValue_AppliesToPair); + + myActualPointOnCurve1 = theActualPointOnCurve1; + + myActualPointOnCurve2 = theActualPointOnCurve2; +} + +//======================================================================= +//function : ActualPointOnCurve1 +//purpose : +//======================================================================= +Handle(StepGeom_PointOnCurve) StepKinematics_SlidingCurvePairValue::ActualPointOnCurve1 () const +{ + return myActualPointOnCurve1; +} + +//======================================================================= +//function : SetActualPointOnCurve1 +//purpose : +//======================================================================= +void StepKinematics_SlidingCurvePairValue::SetActualPointOnCurve1 (const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve1) +{ + myActualPointOnCurve1 = theActualPointOnCurve1; +} + +//======================================================================= +//function : ActualPointOnCurve2 +//purpose : +//======================================================================= +Handle(StepGeom_PointOnCurve) StepKinematics_SlidingCurvePairValue::ActualPointOnCurve2 () const +{ + return myActualPointOnCurve2; +} + +//======================================================================= +//function : SetActualPointOnCurve2 +//purpose : +//======================================================================= +void StepKinematics_SlidingCurvePairValue::SetActualPointOnCurve2 (const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve2) +{ + myActualPointOnCurve2 = theActualPointOnCurve2; +} diff --git a/src/StepKinematics/StepKinematics_SlidingCurvePairValue.hxx b/src/StepKinematics/StepKinematics_SlidingCurvePairValue.hxx new file mode 100644 index 0000000000..1ef135609f --- /dev/null +++ b/src/StepKinematics/StepKinematics_SlidingCurvePairValue.hxx @@ -0,0 +1,61 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_SlidingCurvePairValue_HeaderFile_ +#define _StepKinematics_SlidingCurvePairValue_HeaderFile_ + +#include +#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(); + + //! Initialize all fields (own and inherited) + Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve1, + const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve2); + + //! Returns field ActualPointOnCurve1 + Standard_EXPORT Handle(StepGeom_PointOnCurve) ActualPointOnCurve1() const; + //! Sets field ActualPointOnCurve1 + Standard_EXPORT void SetActualPointOnCurve1 (const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve1); + + //! Returns field ActualPointOnCurve2 + Standard_EXPORT Handle(StepGeom_PointOnCurve) ActualPointOnCurve2() const; + //! Sets field ActualPointOnCurve2 + Standard_EXPORT void SetActualPointOnCurve2 (const Handle(StepGeom_PointOnCurve)& theActualPointOnCurve2); + +DEFINE_STANDARD_RTTIEXT(StepKinematics_SlidingCurvePairValue, StepKinematics_PairValue) + +private: + Handle(StepGeom_PointOnCurve) myActualPointOnCurve1; + Handle(StepGeom_PointOnCurve) myActualPointOnCurve2; + +}; +#endif // _StepKinematics_SlidingCurvePairValue_HeaderFile_ diff --git a/src/StepKinematics/StepKinematics_SlidingSurfacePair.cxx b/src/StepKinematics/StepKinematics_SlidingSurfacePair.cxx new file mode 100644 index 0000000000..81dc94f326 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SlidingSurfacePair.cxx @@ -0,0 +1,27 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..4130201aa5 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SlidingSurfacePair.hxx @@ -0,0 +1,43 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_SlidingSurfacePair_HeaderFile_ +#define _StepKinematics_SlidingSurfacePair_HeaderFile_ + +#include +#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..ca418d08ea --- /dev/null +++ b/src/StepKinematics/StepKinematics_SlidingSurfacePairValue.cxx @@ -0,0 +1,101 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_SlidingSurfacePairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_SlidingSurfacePairValue +//purpose : +//======================================================================= +StepKinematics_SlidingSurfacePairValue::StepKinematics_SlidingSurfacePairValue () +{ +} + +//======================================================================= +//function : Init +//purpose : +//======================================================================= +void StepKinematics_SlidingSurfacePairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface1, + const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface2, + const Standard_Real theActualRotation) +{ + StepKinematics_PairValue::Init(theRepresentationItem_Name, + thePairValue_AppliesToPair); + + myActualPointOnSurface1 = theActualPointOnSurface1; + + myActualPointOnSurface2 = theActualPointOnSurface2; + + myActualRotation = theActualRotation; +} + +//======================================================================= +//function : ActualPointOnSurface1 +//purpose : +//======================================================================= +Handle(StepGeom_PointOnSurface) StepKinematics_SlidingSurfacePairValue::ActualPointOnSurface1 () const +{ + return myActualPointOnSurface1; +} + +//======================================================================= +//function : SetActualPointOnSurface1 +//purpose : +//======================================================================= +void StepKinematics_SlidingSurfacePairValue::SetActualPointOnSurface1 (const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface1) +{ + myActualPointOnSurface1 = theActualPointOnSurface1; +} + +//======================================================================= +//function : ActualPointOnSurface2 +//purpose : +//======================================================================= +Handle(StepGeom_PointOnSurface) StepKinematics_SlidingSurfacePairValue::ActualPointOnSurface2 () const +{ + return myActualPointOnSurface2; +} + +//======================================================================= +//function : SetActualPointOnSurface2 +//purpose : +//======================================================================= +void StepKinematics_SlidingSurfacePairValue::SetActualPointOnSurface2 (const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface2) +{ + myActualPointOnSurface2 = theActualPointOnSurface2; +} + +//======================================================================= +//function : ActualRotation +//purpose : +//======================================================================= +Standard_Real StepKinematics_SlidingSurfacePairValue::ActualRotation () const +{ + return myActualRotation; +} + +//======================================================================= +//function : SetActualRotation +//purpose : +//======================================================================= +void StepKinematics_SlidingSurfacePairValue::SetActualRotation (const Standard_Real theActualRotation) +{ + myActualRotation = theActualRotation; +} diff --git a/src/StepKinematics/StepKinematics_SlidingSurfacePairValue.hxx b/src/StepKinematics/StepKinematics_SlidingSurfacePairValue.hxx new file mode 100644 index 0000000000..9c54281e33 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SlidingSurfacePairValue.hxx @@ -0,0 +1,68 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_SlidingSurfacePairValue_HeaderFile_ +#define _StepKinematics_SlidingSurfacePairValue_HeaderFile_ + +#include +#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(); + + //! Initialize all fields (own and inherited) + Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface1, + const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface2, + const Standard_Real theActualRotation); + + //! Returns field ActualPointOnSurface1 + Standard_EXPORT Handle(StepGeom_PointOnSurface) ActualPointOnSurface1() const; + //! Sets field ActualPointOnSurface1 + Standard_EXPORT void SetActualPointOnSurface1 (const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface1); + + //! Returns field ActualPointOnSurface2 + Standard_EXPORT Handle(StepGeom_PointOnSurface) ActualPointOnSurface2() const; + //! Sets field ActualPointOnSurface2 + Standard_EXPORT void SetActualPointOnSurface2 (const Handle(StepGeom_PointOnSurface)& theActualPointOnSurface2); + + //! Returns field ActualRotation + Standard_EXPORT Standard_Real ActualRotation() const; + //! Sets field ActualRotation + Standard_EXPORT void SetActualRotation (const Standard_Real theActualRotation); + +DEFINE_STANDARD_RTTIEXT(StepKinematics_SlidingSurfacePairValue, StepKinematics_PairValue) + +private: + Handle(StepGeom_PointOnSurface) myActualPointOnSurface1; + Handle(StepGeom_PointOnSurface) myActualPointOnSurface2; + Standard_Real myActualRotation; + +}; +#endif // _StepKinematics_SlidingSurfacePairValue_HeaderFile_ diff --git a/src/StepKinematics/StepKinematics_SpatialRotation.cxx b/src/StepKinematics/StepKinematics_SpatialRotation.cxx new file mode 100644 index 0000000000..35c627afc7 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SpatialRotation.cxx @@ -0,0 +1,57 @@ +// Created on : Sat May 02 12:41:14 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include +#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..314268cc89 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SpatialRotation.hxx @@ -0,0 +1,53 @@ +// Created on : Sat May 02 12:41:14 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_SpatialRotation_HeaderFile +#define _StepKinematics_SpatialRotation_HeaderFile + +#include +#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..0b3b8afa22 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SphericalPair.cxx @@ -0,0 +1,27 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..37fa34d3a6 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SphericalPair.hxx @@ -0,0 +1,42 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_SphericalPair_HeaderFile_ +#define _StepKinematics_SphericalPair_HeaderFile_ + +#include +#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..af203648dc --- /dev/null +++ b/src/StepKinematics/StepKinematics_SphericalPairSelect.cxx @@ -0,0 +1,57 @@ +// Created on : Sat May 02 12:41:14 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include +#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..f340701388 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SphericalPairSelect.hxx @@ -0,0 +1,53 @@ +// Created on : Sat May 02 12:41:14 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_SphericalPairSelect_HeaderFile +#define _StepKinematics_SphericalPairSelect_HeaderFile + +#include +#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..12fdef9aa7 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SphericalPairValue.cxx @@ -0,0 +1,59 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_SphericalPairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_SphericalPairValue +//purpose : +//======================================================================= +StepKinematics_SphericalPairValue::StepKinematics_SphericalPairValue () +{ +} + +//======================================================================= +//function : Init +//purpose : +//======================================================================= +void StepKinematics_SphericalPairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const StepKinematics_SpatialRotation& theInputOrientation) +{ + StepKinematics_PairValue::Init(theRepresentationItem_Name, + thePairValue_AppliesToPair); + + myInputOrientation = theInputOrientation; +} + +//======================================================================= +//function : InputOrientation +//purpose : +//======================================================================= +StepKinematics_SpatialRotation StepKinematics_SphericalPairValue::InputOrientation () const +{ + return myInputOrientation; +} + +//======================================================================= +//function : SetInputOrientation +//purpose : +//======================================================================= +void StepKinematics_SphericalPairValue::SetInputOrientation (const StepKinematics_SpatialRotation& theInputOrientation) +{ + myInputOrientation = theInputOrientation; +} diff --git a/src/StepKinematics/StepKinematics_SphericalPairValue.hxx b/src/StepKinematics/StepKinematics_SphericalPairValue.hxx new file mode 100644 index 0000000000..4ebd832385 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SphericalPairValue.hxx @@ -0,0 +1,54 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_SphericalPairValue_HeaderFile_ +#define _StepKinematics_SphericalPairValue_HeaderFile_ + +#include +#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(); + + //! Initialize all fields (own and inherited) + Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const StepKinematics_SpatialRotation& theInputOrientation); + + //! Returns field InputOrientation + Standard_EXPORT StepKinematics_SpatialRotation InputOrientation() const; + //! Sets field InputOrientation + Standard_EXPORT void SetInputOrientation (const StepKinematics_SpatialRotation& theInputOrientation); + +DEFINE_STANDARD_RTTIEXT(StepKinematics_SphericalPairValue, StepKinematics_PairValue) + +private: + StepKinematics_SpatialRotation myInputOrientation; + +}; +#endif // _StepKinematics_SphericalPairValue_HeaderFile_ diff --git a/src/StepKinematics/StepKinematics_SphericalPairWithPin.cxx b/src/StepKinematics/StepKinematics_SphericalPairWithPin.cxx new file mode 100644 index 0000000000..d368c46d04 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SphericalPairWithPin.cxx @@ -0,0 +1,27 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..f41db13212 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SphericalPairWithPin.hxx @@ -0,0 +1,42 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_SphericalPairWithPin_HeaderFile_ +#define _StepKinematics_SphericalPairWithPin_HeaderFile_ + +#include +#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..0b876d5b27 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SphericalPairWithPinAndRange.cxx @@ -0,0 +1,204 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..c10e089291 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SphericalPairWithPinAndRange.hxx @@ -0,0 +1,103 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_SphericalPairWithPinAndRange_HeaderFile_ +#define _StepKinematics_SphericalPairWithPinAndRange_HeaderFile_ + +#include +#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..b43479ba1d --- /dev/null +++ b/src/StepKinematics/StepKinematics_SphericalPairWithRange.cxx @@ -0,0 +1,276 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..9e771f913a --- /dev/null +++ b/src/StepKinematics/StepKinematics_SphericalPairWithRange.hxx @@ -0,0 +1,125 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_SphericalPairWithRange_HeaderFile_ +#define _StepKinematics_SphericalPairWithRange_HeaderFile_ + +#include +#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_SurfacePair.cxx b/src/StepKinematics/StepKinematics_SurfacePair.cxx new file mode 100644 index 0000000000..71c2d5b9cb --- /dev/null +++ b/src/StepKinematics/StepKinematics_SurfacePair.cxx @@ -0,0 +1,111 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..54b19045ef --- /dev/null +++ b/src/StepKinematics/StepKinematics_SurfacePair.hxx @@ -0,0 +1,75 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_SurfacePair_HeaderFile_ +#define _StepKinematics_SurfacePair_HeaderFile_ + +#include +#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..7c36fd1b55 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SurfacePairWithRange.cxx @@ -0,0 +1,168 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..3c75f3f903 --- /dev/null +++ b/src/StepKinematics/StepKinematics_SurfacePairWithRange.hxx @@ -0,0 +1,94 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_SurfacePairWithRange_HeaderFile_ +#define _StepKinematics_SurfacePairWithRange_HeaderFile_ + +#include +#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..ad9720aaf8 --- /dev/null +++ b/src/StepKinematics/StepKinematics_UnconstrainedPair.cxx @@ -0,0 +1,27 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..f3b4f81904 --- /dev/null +++ b/src/StepKinematics/StepKinematics_UnconstrainedPair.hxx @@ -0,0 +1,42 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_UnconstrainedPair_HeaderFile_ +#define _StepKinematics_UnconstrainedPair_HeaderFile_ + +#include +#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..7d4095b3ac --- /dev/null +++ b/src/StepKinematics/StepKinematics_UnconstrainedPairValue.cxx @@ -0,0 +1,59 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_UnconstrainedPairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_UnconstrainedPairValue +//purpose : +//======================================================================= +StepKinematics_UnconstrainedPairValue::StepKinematics_UnconstrainedPairValue () +{ +} + +//======================================================================= +//function : Init +//purpose : +//======================================================================= +void StepKinematics_UnconstrainedPairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Handle(StepGeom_Axis2Placement3d)& theActualPlacement) +{ + StepKinematics_PairValue::Init(theRepresentationItem_Name, + thePairValue_AppliesToPair); + + myActualPlacement = theActualPlacement; +} + +//======================================================================= +//function : ActualPlacement +//purpose : +//======================================================================= +Handle(StepGeom_Axis2Placement3d) StepKinematics_UnconstrainedPairValue::ActualPlacement () const +{ + return myActualPlacement; +} + +//======================================================================= +//function : SetActualPlacement +//purpose : +//======================================================================= +void StepKinematics_UnconstrainedPairValue::SetActualPlacement (const Handle(StepGeom_Axis2Placement3d)& theActualPlacement) +{ + myActualPlacement = theActualPlacement; +} diff --git a/src/StepKinematics/StepKinematics_UnconstrainedPairValue.hxx b/src/StepKinematics/StepKinematics_UnconstrainedPairValue.hxx new file mode 100644 index 0000000000..359785270b --- /dev/null +++ b/src/StepKinematics/StepKinematics_UnconstrainedPairValue.hxx @@ -0,0 +1,54 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_UnconstrainedPairValue_HeaderFile_ +#define _StepKinematics_UnconstrainedPairValue_HeaderFile_ + +#include +#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(); + + //! Initialize all fields (own and inherited) + Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Handle(StepGeom_Axis2Placement3d)& theActualPlacement); + + //! Returns field ActualPlacement + Standard_EXPORT Handle(StepGeom_Axis2Placement3d) ActualPlacement() const; + //! Sets field ActualPlacement + Standard_EXPORT void SetActualPlacement (const Handle(StepGeom_Axis2Placement3d)& theActualPlacement); + +DEFINE_STANDARD_RTTIEXT(StepKinematics_UnconstrainedPairValue, StepKinematics_PairValue) + +private: + Handle(StepGeom_Axis2Placement3d) myActualPlacement; + +}; +#endif // _StepKinematics_UnconstrainedPairValue_HeaderFile_ diff --git a/src/StepKinematics/StepKinematics_UniversalPair.cxx b/src/StepKinematics/StepKinematics_UniversalPair.cxx new file mode 100644 index 0000000000..d9103609e9 --- /dev/null +++ b/src/StepKinematics/StepKinematics_UniversalPair.cxx @@ -0,0 +1,96 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..af35c66061 --- /dev/null +++ b/src/StepKinematics/StepKinematics_UniversalPair.hxx @@ -0,0 +1,70 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_UniversalPair_HeaderFile_ +#define _StepKinematics_UniversalPair_HeaderFile_ + +#include +#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..56d38f0737 --- /dev/null +++ b/src/StepKinematics/StepKinematics_UniversalPairValue.cxx @@ -0,0 +1,80 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +IMPLEMENT_STANDARD_RTTIEXT(StepKinematics_UniversalPairValue, StepKinematics_PairValue) + +//======================================================================= +//function : StepKinematics_UniversalPairValue +//purpose : +//======================================================================= +StepKinematics_UniversalPairValue::StepKinematics_UniversalPairValue () +{ +} + +//======================================================================= +//function : Init +//purpose : +//======================================================================= +void StepKinematics_UniversalPairValue::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Standard_Real theFirstRotationAngle, + const Standard_Real theSecondRotationAngle) +{ + StepKinematics_PairValue::Init(theRepresentationItem_Name, + thePairValue_AppliesToPair); + + myFirstRotationAngle = theFirstRotationAngle; + + mySecondRotationAngle = theSecondRotationAngle; +} + +//======================================================================= +//function : FirstRotationAngle +//purpose : +//======================================================================= +Standard_Real StepKinematics_UniversalPairValue::FirstRotationAngle () const +{ + return myFirstRotationAngle; +} + +//======================================================================= +//function : SetFirstRotationAngle +//purpose : +//======================================================================= +void StepKinematics_UniversalPairValue::SetFirstRotationAngle (const Standard_Real theFirstRotationAngle) +{ + myFirstRotationAngle = theFirstRotationAngle; +} + +//======================================================================= +//function : SecondRotationAngle +//purpose : +//======================================================================= +Standard_Real StepKinematics_UniversalPairValue::SecondRotationAngle () const +{ + return mySecondRotationAngle; +} + +//======================================================================= +//function : SetSecondRotationAngle +//purpose : +//======================================================================= +void StepKinematics_UniversalPairValue::SetSecondRotationAngle (const Standard_Real theSecondRotationAngle) +{ + mySecondRotationAngle = theSecondRotationAngle; +} diff --git a/src/StepKinematics/StepKinematics_UniversalPairValue.hxx b/src/StepKinematics/StepKinematics_UniversalPairValue.hxx new file mode 100644 index 0000000000..e132930be7 --- /dev/null +++ b/src/StepKinematics/StepKinematics_UniversalPairValue.hxx @@ -0,0 +1,60 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_UniversalPairValue_HeaderFile_ +#define _StepKinematics_UniversalPairValue_HeaderFile_ + +#include +#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(); + + //! Initialize all fields (own and inherited) + Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name, + const Handle(StepKinematics_KinematicPair)& thePairValue_AppliesToPair, + const Standard_Real theFirstRotationAngle, + const Standard_Real theSecondRotationAngle); + + //! Returns field FirstRotationAngle + Standard_EXPORT Standard_Real FirstRotationAngle() const; + //! Sets field FirstRotationAngle + Standard_EXPORT void SetFirstRotationAngle (const Standard_Real theFirstRotationAngle); + + //! Returns field SecondRotationAngle + Standard_EXPORT Standard_Real SecondRotationAngle() const; + //! Sets field SecondRotationAngle + Standard_EXPORT void SetSecondRotationAngle (const Standard_Real theSecondRotationAngle); + +DEFINE_STANDARD_RTTIEXT(StepKinematics_UniversalPairValue, StepKinematics_PairValue) + +private: + Standard_Real myFirstRotationAngle; + Standard_Real mySecondRotationAngle; + +}; +#endif // _StepKinematics_UniversalPairValue_HeaderFile_ diff --git a/src/StepKinematics/StepKinematics_UniversalPairWithRange.cxx b/src/StepKinematics/StepKinematics_UniversalPairWithRange.cxx new file mode 100644 index 0000000000..9fd98da7a8 --- /dev/null +++ b/src/StepKinematics/StepKinematics_UniversalPairWithRange.cxx @@ -0,0 +1,208 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..3aa2ee8c1a --- /dev/null +++ b/src/StepKinematics/StepKinematics_UniversalPairWithRange.hxx @@ -0,0 +1,105 @@ +// Created on : Sat May 02 12:41:16 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepKinematics_UniversalPairWithRange_HeaderFile_ +#define _StepKinematics_UniversalPairWithRange_HeaderFile_ + +#include +#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..3891cad5f4 100644 --- a/src/StepRepr/StepRepr_ItemDefinedTransformation.hxx +++ b/src/StepRepr/StepRepr_ItemDefinedTransformation.hxx @@ -42,6 +42,8 @@ public: Standard_EXPORT void SetName (const Handle(TCollection_HAsciiString)& aName); Standard_EXPORT Handle(TCollection_HAsciiString) Name() const; + + Standard_Boolean HasDescription() const { return !theDescription.IsNull(); } Standard_EXPORT void SetDescription (const Handle(TCollection_HAsciiString)& aDescription); diff --git a/src/StepRepr/StepRepr_RepresentationContextReference.cxx b/src/StepRepr/StepRepr_RepresentationContextReference.cxx new file mode 100644 index 0000000000..6f1aa37ba5 --- /dev/null +++ b/src/StepRepr/StepRepr_RepresentationContextReference.cxx @@ -0,0 +1,59 @@ +// Created on : Sat May 02 12:41:14 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..757246542a --- /dev/null +++ b/src/StepRepr/StepRepr_RepresentationContextReference.hxx @@ -0,0 +1,50 @@ +// Created on : Sat May 02 12:41:14 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepRepr_RepresentationContextReference_HeaderFile_ +#define _StepRepr_RepresentationContextReference_HeaderFile_ + +#include +#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..2232141c72 --- /dev/null +++ b/src/StepRepr/StepRepr_RepresentationOrRepresentationReference.cxx @@ -0,0 +1,61 @@ +// Created on : Sat May 02 12:41:14 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include +#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..bad4a602cd --- /dev/null +++ b/src/StepRepr/StepRepr_RepresentationOrRepresentationReference.hxx @@ -0,0 +1,53 @@ +// Created on : Sat May 02 12:41:14 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepRepr_RepresentationOrRepresentationReference_HeaderFile +#define _StepRepr_RepresentationOrRepresentationReference_HeaderFile + +#include +#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..16d392bfe0 --- /dev/null +++ b/src/StepRepr/StepRepr_RepresentationReference.cxx @@ -0,0 +1,82 @@ +// Created on : Sat May 02 12:41:14 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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..24088a235e --- /dev/null +++ b/src/StepRepr/StepRepr_RepresentationReference.hxx @@ -0,0 +1,58 @@ +// Created on : Sat May 02 12:41:14 2020 +// Created by: Irina KRYLOVA +// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V3.0 +// Copyright (c) Open CASCADE 2020 +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _StepRepr_RepresentationReference_HeaderFile_ +#define _StepRepr_RepresentationReference_HeaderFile_ + +#include +#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..2e3c8382fd 100644 --- a/src/StepRepr/StepRepr_RepresentationRelationship.hxx +++ b/src/StepRepr/StepRepr_RepresentationRelationship.hxx @@ -43,6 +43,8 @@ public: Standard_EXPORT void SetName (const Handle(TCollection_HAsciiString)& aName); Standard_EXPORT Handle(TCollection_HAsciiString) Name() const; + + Standard_Boolean HasDescription() { return !description.IsNull(); } Standard_EXPORT void SetDescription (const Handle(TCollection_HAsciiString)& aDescription); diff --git a/src/StepRepr/StepRepr_Transformation.cxx b/src/StepRepr/StepRepr_Transformation.cxx index ea33444708..018648fa31 100644 --- a/src/StepRepr/StepRepr_Transformation.cxx +++ b/src/StepRepr/StepRepr_Transformation.cxx @@ -14,6 +14,7 @@ #include #include +#include #include #include #include @@ -25,6 +26,7 @@ Standard_Integer StepRepr_Transformation::CaseNum(const Handle(Standard_Transien if (ent.IsNull()) return 0; if (ent->IsKind(STANDARD_TYPE(StepRepr_ItemDefinedTransformation))) return 1; if (ent->IsKind(STANDARD_TYPE(StepRepr_FunctionallyDefinedTransformation))) return 2; + if (ent->IsKind(STANDARD_TYPE(StepGeom_GeometricRepresentationItem))) return 1; return 0; } diff --git a/src/StepRepr/StepRepr_Transformation.hxx b/src/StepRepr/StepRepr_Transformation.hxx index b4d59c045d..c1f17c818a 100644 --- a/src/StepRepr/StepRepr_Transformation.hxx +++ b/src/StepRepr/StepRepr_Transformation.hxx @@ -52,8 +52,6 @@ public: Standard_EXPORT Handle(StepRepr_FunctionallyDefinedTransformation) FunctionallyDefinedTransformation() const; - - protected: diff --git a/src/StepToGeom/StepToGeom.cxx b/src/StepToGeom/StepToGeom.cxx index dcbd145a99..bb28924127 100644 --- a/src/StepToGeom/StepToGeom.cxx +++ b/src/StepToGeom/StepToGeom.cxx @@ -131,11 +131,19 @@ #include #include #include +#include +#include +#include #include #include #include +#include +#include +#include +#include +#include //============================================================================= // Creation d' un Ax1Placement de Geom a partir d' un axis1_placement de Step @@ -202,6 +210,28 @@ Handle(Geom_Axis2Placement) StepToGeom::MakeAxis2Placement (const Handle(StepGeo return 0; } +//============================================================================= +// Creation of an AxisPlacement from a Kinematic SuParameters for Step +//============================================================================= + +Handle(Geom_Axis2Placement) StepToGeom::MakeAxis2Placement(const Handle(StepGeom_SuParameters)& theSP) +{ + Standard_Real aLocX = theSP->A() * cos(theSP->Gamma()) + theSP->B() * sin(theSP->Gamma()) * sin(theSP->Alpha()); + Standard_Real aLocY = theSP->A() * sin(theSP->Gamma()) - theSP->B() * cos(theSP->Gamma()) * sin(theSP->Alpha()); + Standard_Real aLocZ = theSP->C() + theSP->B() * cos(theSP->Alpha()); + Standard_Real anAsisX = sin(theSP->Gamma()) * sin(theSP->Alpha()); + Standard_Real anAxisY = -cos(theSP->Gamma()) * sin(theSP->Alpha()); + Standard_Real anAxisZ = cos(theSP->Alpha()); + Standard_Real aDirX = cos(theSP->Gamma()) * cos(theSP->Beta()) - sin(theSP->Gamma()) * cos(theSP->Alpha()) * sin(theSP->Beta()); + Standard_Real aDirY = sin(theSP->Gamma()) * cos(theSP->Beta()) + cos(theSP->Gamma()) * cos(theSP->Alpha()) * sin(theSP->Beta()); + Standard_Real aDirZ = sin(theSP->Alpha())*sin(theSP->Beta()); + const gp_Pnt Pgp (aLocX, aLocY, aLocZ); + const gp_Dir Ngp (anAsisX,anAxisY,anAxisZ); + const gp_Dir Vxgp(aDirX, aDirY, aDirZ); + gp_Ax2 gpAx2 = gp_Ax2(Pgp, Ngp, Vxgp); + return new Geom_Axis2Placement(gpAx2); +} + //============================================================================= // Creation d' un AxisPlacement de Geom2d a partir d' un axis2_placement_3d de Step //============================================================================= @@ -2179,3 +2209,222 @@ Handle(Geom2d_VectorWithMagnitude) StepToGeom::MakeVectorWithMagnitude2d (const } return 0; } + +//============================================================================= +// Creation of a YptRotation from a Kinematic SpatialRotation for Step +//============================================================================= + +Handle(TColStd_HArray1OfReal) StepToGeom::MakeYprRotation(const StepKinematics_SpatialRotation& SR, const Handle(StepRepr_GlobalUnitAssignedContext)& theCntxt) +{ + //If rotation is already a ypr_rotation, return it immediately + Handle(TColStd_HArray1OfReal) anYPRRotation; + if (!SR.YprRotation().IsNull() && + SR.YprRotation()->Length() == 3) + { + return SR.YprRotation(); + } + + if (SR.RotationAboutDirection().IsNull() || + SR.RotationAboutDirection()->DirectionOfAxis()->DirectionRatios()->Length() != 3 || + theCntxt.IsNull()) + { + return NULL; + } + //rotation is a rotation_about_direction + Handle(Geom_Direction) anAxis; + anAxis = new Geom_Direction(SR.RotationAboutDirection()->DirectionOfAxis()->DirectionRatiosValue(1), + SR.RotationAboutDirection()->DirectionOfAxis()->DirectionRatiosValue(2), + SR.RotationAboutDirection()->DirectionOfAxis()->DirectionRatiosValue(3)); + Standard_Real anAngle = SR.RotationAboutDirection()->RotationAngle(); + if (Abs(anAngle) < Precision::Angular()) + { + // a zero rotation is converted trivially + anYPRRotation = new TColStd_HArray1OfReal(1, 3); + anYPRRotation->SetValue(1, 0.); + anYPRRotation->SetValue(2, 0.); + anYPRRotation->SetValue(3, 0.); + return anYPRRotation; + } + Standard_Real dx = anAxis->X(); + Standard_Real dy = anAxis->Y(); + Standard_Real dz = anAxis->Z(); + NCollection_Sequence aPaUnits; + for (Standard_Integer anInd = 1; anInd <= theCntxt->Units()->Length(); ++anInd) + { + if (theCntxt->UnitsValue(anInd)->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndPlaneAngleUnit)) || + theCntxt->UnitsValue(anInd)->IsKind(STANDARD_TYPE(StepBasic_SiUnitAndPlaneAngleUnit))) + { + aPaUnits.Append(theCntxt->UnitsValue(anInd)); + } + } + if (aPaUnits.Length() != 1) + { + return anYPRRotation; + } + Handle(StepBasic_NamedUnit) aPau = aPaUnits.Value(1); + while (!aPau.IsNull() && aPau->IsKind((STANDARD_TYPE(StepBasic_ConversionBasedUnitAndPlaneAngleUnit)))) + { + Handle(StepBasic_ConversionBasedUnitAndPlaneAngleUnit) aConverUnit = Handle(StepBasic_ConversionBasedUnitAndPlaneAngleUnit)::DownCast(aPau); + anAngle = anAngle * aConverUnit->ConversionFactor()->ValueComponent(); + aPau = aConverUnit->ConversionFactor()->UnitComponent().NamedUnit(); + } + if (aPau.IsNull()) + { + return anYPRRotation; + } + Handle(StepBasic_SiUnitAndPlaneAngleUnit) aSiUnit = Handle(StepBasic_SiUnitAndPlaneAngleUnit)::DownCast(aPau); + if (aSiUnit.IsNull() || aSiUnit->Name() != StepBasic_sunRadian) + { + return anYPRRotation; + } + anAngle = (!aSiUnit->HasPrefix() ? + 1. : STEPConstruct_UnitContext::ConvertSiPrefix(aSiUnit->Prefix())) * anAngle; + Standard_Real anUcf = SR.RotationAboutDirection()->RotationAngle() / anAngle; + Standard_Real aSA = Sin(anAngle); + Standard_Real aCA = Cos(anAngle); + Standard_Real aYaw = 0, aPitch = 0, aRoll = 0; + + // axis parallel either to x-axis or to z-axis? + if (Abs(dy) < Precision::Confusion() && Abs(dx * dz) < Precision::SquareConfusion()) + { + while (anAngle <= -M_PI) + { + anAngle = anAngle + 2 * M_PI; + } + while (anAngle > M_PI) + { + anAngle = anAngle - 2 * M_PI; + } + + aYaw = anUcf * anAngle; + if (Abs(anAngle - M_PI) >= Precision::Angular()) + { + aRoll = -aYaw; + } + else + { + aRoll = aYaw; + } + anYPRRotation = new TColStd_HArray1OfReal(1, 3); + anYPRRotation->SetValue(1, 0.); + anYPRRotation->SetValue(2, 0.); + anYPRRotation->SetValue(3, 0.); + if (Abs(dx) >= Precision::Confusion()) + { + if (dx > 0.) + anYPRRotation->SetValue(3, aYaw); + else + anYPRRotation->SetValue(3, aRoll); + } + else + { + if (dz > 0.) + anYPRRotation->SetValue(1, aYaw); + else + anYPRRotation->SetValue(1, aRoll); + } + return anYPRRotation; + } + + // axis parallel to y-axis - use y-axis as pitch axis + if (Abs(dy) >= Precision::Confusion() && Abs(dx) < Precision::Confusion() && Abs(dz) < Precision::Confusion()) + { + if (aCA >= 0.) + { + aYaw = 0.0; + aRoll = 0.0; + } + else + { + aYaw = anUcf * M_PI; + aRoll = aYaw; + } + aPitch = anUcf * ATan2(aSA, Abs(aCA)); + if (dy < 0.) + { + aPitch = -aPitch; + } + anYPRRotation = new TColStd_HArray1OfReal(1, 3); + anYPRRotation->SetValue(1, aYaw); + anYPRRotation->SetValue(2, aPitch); + anYPRRotation->SetValue(3, aRoll); + return anYPRRotation; + } + // axis not parallel to any axis of coordinate system + // compute rotation matrix + Standard_Real aCm1 = 1 - aCA; + + Standard_Real aRotMat[3][3] = { { dx * dx * aCm1 + aCA ,dx * dy * aCm1 - dz * aSA, dx * dz * aCm1 + dy * aSA }, + { dx * dy * aCm1 + dz * aSA,dy * dy * aCm1 + aCA, dy * dz * aCm1 - dx * aSA }, + { dx * dz * aCm1 - dy * aSA, dy * dz * aCm1 + dx * aSA,dz * dz * aCm1 + aCA } }; + + // aRotMat[1][3] equals SIN(pitch_angle) + if (Abs(Abs(aRotMat[0][2] - 1.)) < Precision::Confusion()) + { + // |aPitch| = PI/2 + if (Abs(aRotMat[0][2] - 1.) < Precision::Confusion()) + aPitch = M_PI_2; + else + aPitch = -M_PI_2; + // In this case, only the sum or difference of roll and yaw angles + // is relevant and can be evaluated from the matrix. + // According to IP `rectangular pitch angle' for ypr_rotation, + // the roll angle is set to zero. + aRoll = 0.; + aYaw = ATan2(aRotMat[1][0], aRotMat[1][1]); + // result of ATAN is in the range[-PI / 2, PI / 2]. + // Here all four quadrants are needed. + + if (aRotMat[1][1] < 0.) + { + if (aYaw <= 0.) + aYaw = aYaw + M_PI; + else + aYaw = aYaw - M_PI; + } + } + else + { + // COS (pitch_angle) not equal to zero + aYaw = ATan2(-aRotMat[0][1], aRotMat[0][0]); + + if (aRotMat[0][0] < 0.) + { + if (aYaw < 0. || Abs(aYaw) < Precision::Angular()) + aYaw = aYaw + M_PI; + else + aYaw = aYaw - M_PI; + } + Standard_Real aSY = Sin(aYaw); + Standard_Real aCY = Cos(aYaw); + Standard_Real aSR = Sin(aRoll); + Standard_Real aCR = Cos(aRoll); + + if (Abs(aSY) > Abs(aCY) && + Abs(aSY) > Abs(aSR) && + Abs(aSY) > Abs(aCR)) + { + aCm1 = -aRotMat[0][1] / aSY; + } + else + { + if (Abs(aCY) > Abs(aSR) && Abs(aCY) > Abs(aCR)) + aCm1 = aRotMat[0][0] / aCY; + else + if (Abs(aSR) > Abs(aCR)) + aCm1 = -aRotMat[1][2] / aSR; + else + aCm1 = aRotMat[2][2] / aCR; + } + aPitch = ATan2(aRotMat[0][2], aCm1); + } + aYaw = aYaw * anUcf; + aPitch = aPitch * anUcf; + aRoll = aRoll * anUcf; + anYPRRotation = new TColStd_HArray1OfReal(1, 3); + anYPRRotation->SetValue(1, aYaw); + anYPRRotation->SetValue(2, aPitch); + anYPRRotation->SetValue(3, aRoll); + + return anYPRRotation; +} diff --git a/src/StepToGeom/StepToGeom.hxx b/src/StepToGeom/StepToGeom.hxx index d95d975597..b708d25951 100644 --- a/src/StepToGeom/StepToGeom.hxx +++ b/src/StepToGeom/StepToGeom.hxx @@ -100,6 +100,10 @@ class StepGeom_CartesianTransformationOperator2d; class StepGeom_CartesianTransformationOperator3d; class StepGeom_TrimmedCurve; class StepGeom_Vector; +class StepGeom_SuParameters; +class StepKinematics_SpatialRotation; +class StepRepr_GlobalUnitAssignedContext; +class TColStd_HArray1OfReal; //! This class provides static methods to convert STEP geometric entities to OCCT. //! The methods returning handles will return null handle in case of error. @@ -111,6 +115,7 @@ public: Standard_EXPORT static Handle(Geom_Axis1Placement) MakeAxis1Placement (const Handle(StepGeom_Axis1Placement)& SA); Standard_EXPORT static Handle(Geom_Axis2Placement) MakeAxis2Placement (const Handle(StepGeom_Axis2Placement3d)& SA); + Standard_EXPORT static Handle(Geom_Axis2Placement) MakeAxis2Placement (const Handle(StepGeom_SuParameters)& SP); Standard_EXPORT static Handle(Geom2d_AxisPlacement) MakeAxisPlacement (const Handle(StepGeom_Axis2Placement2d)& SA); Standard_EXPORT static Handle(Geom_BoundedCurve) MakeBoundedCurve (const Handle(StepGeom_BoundedCurve)& SC); Standard_EXPORT static Handle(Geom2d_BoundedCurve) MakeBoundedCurve2d (const Handle(StepGeom_BoundedCurve)& SC); @@ -155,6 +160,7 @@ public: Standard_EXPORT static Handle(Geom2d_BSplineCurve) MakeTrimmedCurve2d (const Handle(StepGeom_TrimmedCurve)& SC); Standard_EXPORT static Handle(Geom_VectorWithMagnitude) MakeVectorWithMagnitude (const Handle(StepGeom_Vector)& SV); Standard_EXPORT static Handle(Geom2d_VectorWithMagnitude) MakeVectorWithMagnitude2d (const Handle(StepGeom_Vector)& SV); + Standard_EXPORT static Handle(TColStd_HArray1OfReal) MakeYprRotation(const StepKinematics_SpatialRotation& SR, const Handle(StepRepr_GlobalUnitAssignedContext)& theCntxt); }; #endif // _StepToGeom_HeaderFile 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