0031388: Data Exchange - support kinematics data in STEP format

- add new STEP entities.

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

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 <RWStepGeom_RWSuParameters.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepGeom_SuParameters.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepGeom_RWSuParameters
+//purpose  : 
+//=======================================================================
+
+RWStepGeom_RWSuParameters::RWStepGeom_RWSuParameters() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  : 
+//=======================================================================
+
+void RWStepGeom_RWSuParameters::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                          const Standard_Integer theNum,
+                                          Handle(Interface_Check)& theAch,
+                                          const Handle(StepGeom_SuParameters)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,7,theAch,"su_parameters") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theAch, aRepresentationItem_Name);
+
+  // Own fields of SuParameters
+
+  Standard_Real aA;
+  theData->ReadReal (theNum, 2, "a", theAch, aA);
+
+  Standard_Real aAlpha;
+  theData->ReadReal (theNum, 3, "alpha", theAch, aAlpha);
+
+  Standard_Real aB;
+  theData->ReadReal (theNum, 4, "b", theAch, aB);
+
+  Standard_Real aBeta;
+  theData->ReadReal (theNum, 5, "beta", theAch, aBeta);
+
+  Standard_Real aC;
+  theData->ReadReal (theNum, 6, "c", theAch, aC);
+
+  Standard_Real aGamma;
+  theData->ReadReal (theNum, 7, "gamma", theAch, aGamma);
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aA,
+            aAlpha,
+            aB,
+            aBeta,
+            aC,
+            aGamma);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  : 
+//=======================================================================
+
+void RWStepGeom_RWSuParameters::WriteStep (StepData_StepWriter& theSW,
+                                           const Handle(StepGeom_SuParameters)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Own fields of SuParameters
+
+  theSW.Send (theEnt->A());
+
+  theSW.Send (theEnt->Alpha());
+
+  theSW.Send (theEnt->B());
+
+  theSW.Send (theEnt->Beta());
+
+  theSW.Send (theEnt->C());
+
+  theSW.Send (theEnt->Gamma());
+}
+
+//=======================================================================
+//function : Share
+//purpose  : 
+//=======================================================================
+
+void RWStepGeom_RWSuParameters::Share (const Handle(StepGeom_SuParameters)& /*theEnt*/,
+                                       Interface_EntityIterator& /*iter*/) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Own fields of SuParameters
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepGeom_SuParameters;
+
+//! Read & Write tool for SuParameters
+class RWStepGeom_RWSuParameters
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepGeom_RWSuParameters();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theAch, const Handle(StepGeom_SuParameters)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepGeom_SuParameters)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepGeom_SuParameters)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepGeom_RWSuParameters_HeaderFile_

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

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_ActuatedKinPairAndOrderKinPair;
+
+
+//! Read & Write Module for GeoTolAndGeoTolWthMod
+class RWStepKinematics_RWActuatedKinPairAndOrderKinPair
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  
+  Standard_EXPORT RWStepKinematics_RWActuatedKinPairAndOrderKinPair();
+  
+  Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_ActuatedKinPairAndOrderKinPair)& theEnt) const;
+  
+  Standard_EXPORT void WriteStep (StepData_StepWriter& theSW, const Handle(StepKinematics_ActuatedKinPairAndOrderKinPair)& theEnt) const;
+  
+  Standard_EXPORT void Share (const Handle(StepKinematics_ActuatedKinPairAndOrderKinPair)& theEnt, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepDimTol_RWGeoTolAndGeoTolWthMod_HeaderFile

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 <RWStepKinematics_RWActuatedKinematicPair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_ActuatedKinematicPair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepKinematics_ActuatedDirection.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWActuatedKinematicPair
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWActuatedKinematicPair::RWStepKinematics_RWActuatedKinematicPair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWActuatedKinematicPair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                         const Standard_Integer theNum,
+                                                         Handle(Interface_Check)& theArch,
+                                                         const Handle(StepKinematics_ActuatedKinematicPair)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,12,theArch,"actuated_kinematic_pair") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of ItemDefinedTransformation
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+  theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+  Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+  if ( theData->IsParamDefined (theNum,3) ) {
+    theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+  }
+  else {
+    hasItemDefinedTransformation_Description = Standard_False;
+    aItemDefinedTransformation_Description.Nullify();
+  }
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+  theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+  theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+  // Inherited fields of KinematicPair
+
+  Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+  theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+  // Own fields of ActuatedKinematicPair
+
+  StepKinematics_ActuatedDirection aTX = StepKinematics_adNotActuated;
+  Standard_Boolean hasTX = Standard_True;
+  if ( theData->IsParamDefined (theNum,7) ) {
+    if (theData->ParamType (theNum, 7) == Interface_ParamEnum) {
+      Standard_CString text = theData->ParamCValue(theNum, 7);
+      if      (strcmp(text, ".BIDIRECTIONAL.")) aTX = StepKinematics_adBidirectional;
+      else if (strcmp(text, ".POSITIVE_ONLY.")) aTX = StepKinematics_adPositiveOnly;
+      else if (strcmp(text, ".NEGATIVE_ONLY.")) aTX = StepKinematics_adNegativeOnly;
+      else if (strcmp(text, ".NOT_ACTUATED.")) aTX = StepKinematics_adNotActuated;
+      else theArch->AddFail("Parameter #7 (t_x) has not allowed value");
+    }
+    else theArch->AddFail("Parameter #7 (t_x) is not enumeration");
+  }
+  else {
+    hasTX = Standard_False;
+  }
+
+  StepKinematics_ActuatedDirection aTY = StepKinematics_adNotActuated;
+  Standard_Boolean hasTY = Standard_True;
+  if ( theData->IsParamDefined (theNum,8) ) {
+    if (theData->ParamType (theNum, 8) == Interface_ParamEnum) {
+      Standard_CString text = theData->ParamCValue(theNum, 8);
+      if      (strcmp(text, ".BIDIRECTIONAL.")) aTY = StepKinematics_adBidirectional;
+      else if (strcmp(text, ".POSITIVE_ONLY.")) aTY = StepKinematics_adPositiveOnly;
+      else if (strcmp(text, ".NEGATIVE_ONLY.")) aTY = StepKinematics_adNegativeOnly;
+      else if (strcmp(text, ".NOT_ACTUATED.")) aTY = StepKinematics_adNotActuated;
+      else theArch->AddFail("Parameter #8 (t_y) has not allowed value");
+    }
+    else theArch->AddFail("Parameter #8 (t_y) is not enumeration");
+  }
+  else {
+    hasTY = Standard_False;
+  }
+
+  StepKinematics_ActuatedDirection aTZ = StepKinematics_adNotActuated;
+  Standard_Boolean hasTZ = Standard_True;
+  if ( theData->IsParamDefined (theNum,9) ) {
+    if (theData->ParamType (theNum, 9) == Interface_ParamEnum) {
+      Standard_CString text = theData->ParamCValue(theNum, 9);
+      if      (strcmp(text, ".BIDIRECTIONAL.")) aTZ = StepKinematics_adBidirectional;
+      else if (strcmp(text, ".POSITIVE_ONLY.")) aTZ = StepKinematics_adPositiveOnly;
+      else if (strcmp(text, ".NEGATIVE_ONLY.")) aTZ = StepKinematics_adNegativeOnly;
+      else if (strcmp(text, ".NOT_ACTUATED.")) aTZ = StepKinematics_adNotActuated;
+      else theArch->AddFail("Parameter #9 (t_z) has not allowed value");
+    }
+    else theArch->AddFail("Parameter #9 (t_z) is not enumeration");
+  }
+  else {
+    hasTZ = Standard_False;
+  }
+
+  StepKinematics_ActuatedDirection aRX = StepKinematics_adNotActuated;
+  Standard_Boolean hasRX = Standard_True;
+  if ( theData->IsParamDefined (theNum,10) ) {
+    if (theData->ParamType (theNum, 10) == Interface_ParamEnum) {
+      Standard_CString text = theData->ParamCValue(theNum, 10);
+      if      (strcmp(text, ".BIDIRECTIONAL.")) aRX = StepKinematics_adBidirectional;
+      else if (strcmp(text, ".POSITIVE_ONLY.")) aRX = StepKinematics_adPositiveOnly;
+      else if (strcmp(text, ".NEGATIVE_ONLY.")) aRX = StepKinematics_adNegativeOnly;
+      else if (strcmp(text, ".NOT_ACTUATED.")) aRX = StepKinematics_adNotActuated;
+      else theArch->AddFail("Parameter #10 (r_x) has not allowed value");
+    }
+    else theArch->AddFail("Parameter #10 (r_x) is not enumeration");
+  }
+  else {
+    hasRX = Standard_False;
+  }
+
+  StepKinematics_ActuatedDirection aRY = StepKinematics_adNotActuated;
+  Standard_Boolean hasRY = Standard_True;
+  if ( theData->IsParamDefined (theNum,11) ) {
+    if (theData->ParamType (theNum, 11) == Interface_ParamEnum) {
+      Standard_CString text = theData->ParamCValue(theNum, 11);
+      if      (strcmp(text, ".BIDIRECTIONAL.")) aRY = StepKinematics_adBidirectional;
+      else if (strcmp(text, ".POSITIVE_ONLY.")) aRY = StepKinematics_adPositiveOnly;
+      else if (strcmp(text, ".NEGATIVE_ONLY.")) aRY = StepKinematics_adNegativeOnly;
+      else if (strcmp(text, ".NOT_ACTUATED.")) aRY = StepKinematics_adNotActuated;
+      else theArch->AddFail("Parameter #11 (r_y) has not allowed value");
+    }
+    else theArch->AddFail("Parameter #11 (r_y) is not enumeration");
+  }
+  else {
+    hasRY = Standard_False;
+  }
+
+  StepKinematics_ActuatedDirection aRZ = StepKinematics_adNotActuated;
+  Standard_Boolean hasRZ = Standard_True;
+  if ( theData->IsParamDefined (theNum,12) ) {
+    if (theData->ParamType (theNum, 12) == Interface_ParamEnum) {
+      Standard_CString text = theData->ParamCValue(theNum, 12);
+      if      (strcmp(text, ".BIDIRECTIONAL.")) aRZ = StepKinematics_adBidirectional;
+      else if (strcmp(text, ".POSITIVE_ONLY.")) aRZ = StepKinematics_adPositiveOnly;
+      else if (strcmp(text, ".NEGATIVE_ONLY.")) aRZ = StepKinematics_adNegativeOnly;
+      else if (strcmp(text, ".NOT_ACTUATED.")) aRZ = StepKinematics_adNotActuated;
+      else theArch->AddFail("Parameter #12 (r_z) has not allowed value");
+    }
+    else theArch->AddFail("Parameter #12 (r_z) is not enumeration");
+  }
+  else {
+    hasRZ = Standard_False;
+  }
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aItemDefinedTransformation_Name,
+            hasItemDefinedTransformation_Description,
+            aItemDefinedTransformation_Description,
+            aItemDefinedTransformation_TransformItem1,
+            aItemDefinedTransformation_TransformItem2,
+            aKinematicPair_Joint,
+            hasTX,
+            aTX,
+            hasTY,
+            aTY,
+            hasTZ,
+            aTZ,
+            hasRX,
+            aRX,
+            hasRY,
+            aRY,
+            hasRZ,
+            aRZ);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWActuatedKinematicPair::WriteStep (StepData_StepWriter& theSW,
+                                                          const Handle(StepKinematics_ActuatedKinematicPair)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Inherited fields of ItemDefinedTransformation
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+  if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+    theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+  }
+  else theSW.SendUndef();
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Own fields of KinematicPair
+
+  theSW.Send (theEnt->Joint());
+
+  // Own fields of ActuatedKinematicPair
+
+  if ( theEnt->HasTX() ) {
+    switch (theEnt->TX()) {
+      case StepKinematics_adBidirectional: theSW.SendEnum (".BIDIRECTIONAL."); break;
+      case StepKinematics_adPositiveOnly: theSW.SendEnum (".POSITIVE_ONLY."); break;
+      case StepKinematics_adNegativeOnly: theSW.SendEnum (".NEGATIVE_ONLY."); break;
+      case StepKinematics_adNotActuated: theSW.SendEnum (".NOT_ACTUATED."); break;
+    }
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasTY() ) {
+    switch (theEnt->TY()) {
+      case StepKinematics_adBidirectional: theSW.SendEnum (".BIDIRECTIONAL."); break;
+      case StepKinematics_adPositiveOnly: theSW.SendEnum (".POSITIVE_ONLY."); break;
+      case StepKinematics_adNegativeOnly: theSW.SendEnum (".NEGATIVE_ONLY."); break;
+      case StepKinematics_adNotActuated: theSW.SendEnum (".NOT_ACTUATED."); break;
+    }
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasTZ() ) {
+    switch (theEnt->TZ()) {
+      case StepKinematics_adBidirectional: theSW.SendEnum (".BIDIRECTIONAL."); break;
+      case StepKinematics_adPositiveOnly: theSW.SendEnum (".POSITIVE_ONLY."); break;
+      case StepKinematics_adNegativeOnly: theSW.SendEnum (".NEGATIVE_ONLY."); break;
+      case StepKinematics_adNotActuated: theSW.SendEnum (".NOT_ACTUATED."); break;
+    }
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasRX() ) {
+    switch (theEnt->RX()) {
+      case StepKinematics_adBidirectional: theSW.SendEnum (".BIDIRECTIONAL."); break;
+      case StepKinematics_adPositiveOnly: theSW.SendEnum (".POSITIVE_ONLY."); break;
+      case StepKinematics_adNegativeOnly: theSW.SendEnum (".NEGATIVE_ONLY."); break;
+      case StepKinematics_adNotActuated: theSW.SendEnum (".NOT_ACTUATED."); break;
+    }
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasRY() ) {
+    switch (theEnt->RY()) {
+      case StepKinematics_adBidirectional: theSW.SendEnum (".BIDIRECTIONAL."); break;
+      case StepKinematics_adPositiveOnly: theSW.SendEnum (".POSITIVE_ONLY."); break;
+      case StepKinematics_adNegativeOnly: theSW.SendEnum (".NEGATIVE_ONLY."); break;
+      case StepKinematics_adNotActuated: theSW.SendEnum (".NOT_ACTUATED."); break;
+    }
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasRZ() ) {
+    switch (theEnt->RZ()) {
+      case StepKinematics_adBidirectional: theSW.SendEnum (".BIDIRECTIONAL."); break;
+      case StepKinematics_adPositiveOnly: theSW.SendEnum (".POSITIVE_ONLY."); break;
+      case StepKinematics_adNegativeOnly: theSW.SendEnum (".NEGATIVE_ONLY."); break;
+      case StepKinematics_adNotActuated: theSW.SendEnum (".NOT_ACTUATED."); break;
+    }
+  }
+  else theSW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWActuatedKinematicPair::Share (const Handle(StepKinematics_ActuatedKinematicPair)& theEnt,
+                                                      Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of ItemDefinedTransformation
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Inherited fields of KinematicPair
+
+  iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+  // Own fields of ActuatedKinematicPair
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_ActuatedKinematicPair;
+
+//! Read & Write tool for ActuatedKinematicPair
+class RWStepKinematics_RWActuatedKinematicPair
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWActuatedKinematicPair();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_ActuatedKinematicPair)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_ActuatedKinematicPair)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_ActuatedKinematicPair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWActuatedKinematicPair_HeaderFile_

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 <RWStepKinematics_RWContextDependentKinematicLinkRepresentation.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_ContextDependentKinematicLinkRepresentation.hxx>
+#include <StepKinematics_KinematicLinkRepresentationAssociation.hxx>
+#include <StepKinematics_ProductDefinitionRelationshipKinematics.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWContextDependentKinematicLinkRepresentation
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWContextDependentKinematicLinkRepresentation::RWStepKinematics_RWContextDependentKinematicLinkRepresentation() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWContextDependentKinematicLinkRepresentation::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                                               const Standard_Integer theNum,
+                                                                               Handle(Interface_Check)& theArch,
+                                                                               const Handle(StepKinematics_ContextDependentKinematicLinkRepresentation)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,2,theArch,"context_dependent_kinematic_link_representation") ) return;
+
+  // Own fields of ContextDependentKinematicLinkRepresentation
+
+  Handle(StepKinematics_KinematicLinkRepresentationAssociation) aRepresentationRelation;
+  theData->ReadEntity (theNum, 1, "representation_relation", theArch, STANDARD_TYPE(StepKinematics_KinematicLinkRepresentationAssociation), aRepresentationRelation);
+
+  Handle(StepKinematics_ProductDefinitionRelationshipKinematics) aRepresentedProductRelation;
+  theData->ReadEntity (theNum, 2, "represented_product_relation", theArch, STANDARD_TYPE(StepKinematics_ProductDefinitionRelationshipKinematics), aRepresentedProductRelation);
+
+  // Initialize entity
+  theEnt->Init(aRepresentationRelation,
+            aRepresentedProductRelation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWContextDependentKinematicLinkRepresentation::WriteStep (StepData_StepWriter& theSW,
+                                                                                const Handle(StepKinematics_ContextDependentKinematicLinkRepresentation)& theEnt) const
+{
+
+  // Own fields of ContextDependentKinematicLinkRepresentation
+
+  theSW.Send (theEnt->RepresentationRelation());
+
+  theSW.Send (theEnt->RepresentedProductRelation());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWContextDependentKinematicLinkRepresentation::Share (const Handle(StepKinematics_ContextDependentKinematicLinkRepresentation)& theEnt,
+                                                                            Interface_EntityIterator& iter) const
+{
+
+  // Own fields of ContextDependentKinematicLinkRepresentation
+
+  iter.AddItem (theEnt->RepresentationRelation());
+
+  iter.AddItem (theEnt->RepresentedProductRelation());
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_ContextDependentKinematicLinkRepresentation;
+
+//! Read & Write tool for ContextDependentKinematicLinkRepresentation
+class RWStepKinematics_RWContextDependentKinematicLinkRepresentation
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWContextDependentKinematicLinkRepresentation();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_ContextDependentKinematicLinkRepresentation)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_ContextDependentKinematicLinkRepresentation)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_ContextDependentKinematicLinkRepresentation)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWContextDependentKinematicLinkRepresentation_HeaderFile_

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 <RWStepKinematics_RWCylindricalPair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_CylindricalPair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWCylindricalPair
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWCylindricalPair::RWStepKinematics_RWCylindricalPair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWCylindricalPair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                   const Standard_Integer theNum,
+                                                   Handle(Interface_Check)& theArch,
+                                                   const Handle(StepKinematics_CylindricalPair)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,12,theArch,"cylindrical_pair") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of ItemDefinedTransformation
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+  theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+  Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+  if ( theData->IsParamDefined (theNum,3) ) {
+    theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+  }
+  else {
+    hasItemDefinedTransformation_Description = Standard_False;
+    aItemDefinedTransformation_Description.Nullify();
+  }
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+  theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+  theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+  // Inherited fields of KinematicPair
+
+  Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+  theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+  // Inherited fields of LowOrderKinematicPair
+
+  Standard_Boolean aLowOrderKinematicPair_TX;
+  theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX);
+
+  Standard_Boolean aLowOrderKinematicPair_TY;
+  theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY);
+
+  Standard_Boolean aLowOrderKinematicPair_TZ;
+  theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ);
+
+  Standard_Boolean aLowOrderKinematicPair_RX;
+  theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX);
+
+  Standard_Boolean aLowOrderKinematicPair_RY;
+  theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY);
+
+  Standard_Boolean aLowOrderKinematicPair_RZ;
+  theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ);
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aItemDefinedTransformation_Name,
+            hasItemDefinedTransformation_Description,
+            aItemDefinedTransformation_Description,
+            aItemDefinedTransformation_TransformItem1,
+            aItemDefinedTransformation_TransformItem2,
+            aKinematicPair_Joint,
+            aLowOrderKinematicPair_TX,
+            aLowOrderKinematicPair_TY,
+            aLowOrderKinematicPair_TZ,
+            aLowOrderKinematicPair_RX,
+            aLowOrderKinematicPair_RY,
+            aLowOrderKinematicPair_RZ);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWCylindricalPair::WriteStep (StepData_StepWriter& theSW,
+                                                    const Handle(StepKinematics_CylindricalPair)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Inherited fields of ItemDefinedTransformation
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+  if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+    theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+  }
+  else theSW.SendUndef();
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Own fields of KinematicPair
+
+  theSW.Send (theEnt->Joint());
+
+  // Own fields of LowOrderKinematicPair
+
+  theSW.SendBoolean (theEnt->TX());
+
+  theSW.SendBoolean (theEnt->TY());
+
+  theSW.SendBoolean (theEnt->TZ());
+
+  theSW.SendBoolean (theEnt->RX());
+
+  theSW.SendBoolean (theEnt->RY());
+
+  theSW.SendBoolean (theEnt->RZ());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWCylindricalPair::Share (const Handle(StepKinematics_CylindricalPair)& theEnt,
+                                                Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of ItemDefinedTransformation
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Inherited fields of KinematicPair
+
+  iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+  // Inherited fields of LowOrderKinematicPair
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_CylindricalPair;
+
+//! Read & Write tool for CylindricalPair
+class RWStepKinematics_RWCylindricalPair
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWCylindricalPair();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_CylindricalPair)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_CylindricalPair)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_CylindricalPair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWCylindricalPair_HeaderFile_

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 <RWStepKinematics_RWCylindricalPairValue.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_CylindricalPairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWCylindricalPairValue
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWCylindricalPairValue::RWStepKinematics_RWCylindricalPairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWCylindricalPairValue::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                        const Standard_Integer theNum,
+                                                        Handle(Interface_Check)& theArch,
+                                                        const Handle(StepKinematics_CylindricalPairValue)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,4,theArch,"cylindrical_pair_value") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of PairValue
+
+  Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+  theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+  // Own fields of CylindricalPairValue
+
+  Standard_Real aActualTranslation;
+  theData->ReadReal (theNum, 3, "actual_translation", theArch, aActualTranslation);
+
+  Standard_Real aActualRotation;
+  theData->ReadReal (theNum, 4, "actual_rotation", theArch, aActualRotation);
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aPairValue_AppliesToPair,
+            aActualTranslation,
+            aActualRotation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWCylindricalPairValue::WriteStep (StepData_StepWriter& theSW,
+                                                         const Handle(StepKinematics_CylindricalPairValue)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Own fields of PairValue
+
+  theSW.Send (theEnt->AppliesToPair());
+
+  // Own fields of CylindricalPairValue
+
+  theSW.Send (theEnt->ActualTranslation());
+
+  theSW.Send (theEnt->ActualRotation());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWCylindricalPairValue::Share (const Handle(StepKinematics_CylindricalPairValue)& theEnt,
+                                                     Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of PairValue
+
+  iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair());
+
+  // Own fields of CylindricalPairValue
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_CylindricalPairValue;
+
+//! Read & Write tool for CylindricalPairValue
+class RWStepKinematics_RWCylindricalPairValue
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWCylindricalPairValue();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_CylindricalPairValue)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_CylindricalPairValue)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_CylindricalPairValue)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWCylindricalPairValue_HeaderFile_

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 <RWStepKinematics_RWCylindricalPairWithRange.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_CylindricalPairWithRange.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWCylindricalPairWithRange
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWCylindricalPairWithRange::RWStepKinematics_RWCylindricalPairWithRange() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWCylindricalPairWithRange::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                            const Standard_Integer theNum,
+                                                            Handle(Interface_Check)& theArch,
+                                                            const Handle(StepKinematics_CylindricalPairWithRange)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,16,theArch,"cylindrical_pair_with_range") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of ItemDefinedTransformation
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+  theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+  Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+  if ( theData->IsParamDefined (theNum,3) ) {
+    theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+  }
+  else {
+    hasItemDefinedTransformation_Description = Standard_False;
+    aItemDefinedTransformation_Description.Nullify();
+  }
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+  theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+  theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+  // Inherited fields of KinematicPair
+
+  Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+  theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+  // Inherited fields of LowOrderKinematicPair
+
+  Standard_Boolean aLowOrderKinematicPair_TX;
+  theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX);
+
+  Standard_Boolean aLowOrderKinematicPair_TY;
+  theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY);
+
+  Standard_Boolean aLowOrderKinematicPair_TZ;
+  theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ);
+
+  Standard_Boolean aLowOrderKinematicPair_RX;
+  theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX);
+
+  Standard_Boolean aLowOrderKinematicPair_RY;
+  theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY);
+
+  Standard_Boolean aLowOrderKinematicPair_RZ;
+  theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ);
+
+  // Own fields of CylindricalPairWithRange
+
+  Standard_Real aLowerLimitActualTranslation;
+  Standard_Boolean hasLowerLimitActualTranslation = Standard_True;
+  if ( theData->IsParamDefined (theNum,13) ) {
+    theData->ReadReal (theNum, 13, "lower_limit_actual_translation", theArch, aLowerLimitActualTranslation);
+  }
+  else {
+    hasLowerLimitActualTranslation = Standard_False;
+    aLowerLimitActualTranslation = 0;
+  }
+
+  Standard_Real aUpperLimitActualTranslation;
+  Standard_Boolean hasUpperLimitActualTranslation = Standard_True;
+  if ( theData->IsParamDefined (theNum,14) ) {
+    theData->ReadReal (theNum, 14, "upper_limit_actual_translation", theArch, aUpperLimitActualTranslation);
+  }
+  else {
+    hasUpperLimitActualTranslation = Standard_False;
+    aUpperLimitActualTranslation = 0;
+  }
+
+  Standard_Real aLowerLimitActualRotation;
+  Standard_Boolean hasLowerLimitActualRotation = Standard_True;
+  if ( theData->IsParamDefined (theNum,15) ) {
+    theData->ReadReal (theNum, 15, "lower_limit_actual_rotation", theArch, aLowerLimitActualRotation);
+  }
+  else {
+    hasLowerLimitActualRotation = Standard_False;
+    aLowerLimitActualRotation = 0;
+  }
+
+  Standard_Real aUpperLimitActualRotation;
+  Standard_Boolean hasUpperLimitActualRotation = Standard_True;
+  if ( theData->IsParamDefined (theNum,16) ) {
+    theData->ReadReal (theNum, 16, "upper_limit_actual_rotation", theArch, aUpperLimitActualRotation);
+  }
+  else {
+    hasUpperLimitActualRotation = Standard_False;
+    aUpperLimitActualRotation = 0;
+  }
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aItemDefinedTransformation_Name,
+            hasItemDefinedTransformation_Description,
+            aItemDefinedTransformation_Description,
+            aItemDefinedTransformation_TransformItem1,
+            aItemDefinedTransformation_TransformItem2,
+            aKinematicPair_Joint,
+            aLowOrderKinematicPair_TX,
+            aLowOrderKinematicPair_TY,
+            aLowOrderKinematicPair_TZ,
+            aLowOrderKinematicPair_RX,
+            aLowOrderKinematicPair_RY,
+            aLowOrderKinematicPair_RZ,
+            hasLowerLimitActualTranslation,
+            aLowerLimitActualTranslation,
+            hasUpperLimitActualTranslation,
+            aUpperLimitActualTranslation,
+            hasLowerLimitActualRotation,
+            aLowerLimitActualRotation,
+            hasUpperLimitActualRotation,
+            aUpperLimitActualRotation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWCylindricalPairWithRange::WriteStep (StepData_StepWriter& theSW,
+                                                             const Handle(StepKinematics_CylindricalPairWithRange)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Inherited fields of ItemDefinedTransformation
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+  if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+    theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+  }
+  else theSW.SendUndef();
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Own fields of KinematicPair
+
+  theSW.Send (theEnt->Joint());
+
+  // Own fields of LowOrderKinematicPair
+
+  theSW.SendBoolean (theEnt->TX());
+
+  theSW.SendBoolean (theEnt->TY());
+
+  theSW.SendBoolean (theEnt->TZ());
+
+  theSW.SendBoolean (theEnt->RX());
+
+  theSW.SendBoolean (theEnt->RY());
+
+  theSW.SendBoolean (theEnt->RZ());
+
+  // Own fields of CylindricalPairWithRange
+
+  if ( theEnt->HasLowerLimitActualTranslation() ) {
+    theSW.Send (theEnt->LowerLimitActualTranslation());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasUpperLimitActualTranslation() ) {
+    theSW.Send (theEnt->UpperLimitActualTranslation());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasLowerLimitActualRotation() ) {
+    theSW.Send (theEnt->LowerLimitActualRotation());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasUpperLimitActualRotation() ) {
+    theSW.Send (theEnt->UpperLimitActualRotation());
+  }
+  else theSW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWCylindricalPairWithRange::Share (const Handle(StepKinematics_CylindricalPairWithRange)& theEnt,
+                                                         Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of ItemDefinedTransformation
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Inherited fields of KinematicPair
+
+  iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+  // Inherited fields of LowOrderKinematicPair
+
+  // Own fields of CylindricalPairWithRange
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_CylindricalPairWithRange;
+
+//! Read & Write tool for CylindricalPairWithRange
+class RWStepKinematics_RWCylindricalPairWithRange
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWCylindricalPairWithRange();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_CylindricalPairWithRange)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_CylindricalPairWithRange)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_CylindricalPairWithRange)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWCylindricalPairWithRange_HeaderFile_

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 <RWStepKinematics_RWFullyConstrainedPair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_FullyConstrainedPair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWFullyConstrainedPair
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWFullyConstrainedPair::RWStepKinematics_RWFullyConstrainedPair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWFullyConstrainedPair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                        const Standard_Integer theNum,
+                                                        Handle(Interface_Check)& theArch,
+                                                        const Handle(StepKinematics_FullyConstrainedPair)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,12,theArch,"fully_constrained_pair") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of ItemDefinedTransformation
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+  theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+  Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+  if ( theData->IsParamDefined (theNum,3) ) {
+    theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+  }
+  else {
+    hasItemDefinedTransformation_Description = Standard_False;
+    aItemDefinedTransformation_Description.Nullify();
+  }
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+  theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+  theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+  // Inherited fields of KinematicPair
+
+  Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+  theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+  // Inherited fields of LowOrderKinematicPair
+
+  Standard_Boolean aLowOrderKinematicPair_TX;
+  theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX);
+
+  Standard_Boolean aLowOrderKinematicPair_TY;
+  theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY);
+
+  Standard_Boolean aLowOrderKinematicPair_TZ;
+  theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ);
+
+  Standard_Boolean aLowOrderKinematicPair_RX;
+  theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX);
+
+  Standard_Boolean aLowOrderKinematicPair_RY;
+  theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY);
+
+  Standard_Boolean aLowOrderKinematicPair_RZ;
+  theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ);
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aItemDefinedTransformation_Name,
+            hasItemDefinedTransformation_Description,
+            aItemDefinedTransformation_Description,
+            aItemDefinedTransformation_TransformItem1,
+            aItemDefinedTransformation_TransformItem2,
+            aKinematicPair_Joint,
+            aLowOrderKinematicPair_TX,
+            aLowOrderKinematicPair_TY,
+            aLowOrderKinematicPair_TZ,
+            aLowOrderKinematicPair_RX,
+            aLowOrderKinematicPair_RY,
+            aLowOrderKinematicPair_RZ);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWFullyConstrainedPair::WriteStep (StepData_StepWriter& theSW,
+                                                         const Handle(StepKinematics_FullyConstrainedPair)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Inherited fields of ItemDefinedTransformation
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+  if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+    theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+  }
+  else theSW.SendUndef();
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Own fields of KinematicPair
+
+  theSW.Send (theEnt->Joint());
+
+  // Own fields of LowOrderKinematicPair
+
+  theSW.SendBoolean (theEnt->TX());
+
+  theSW.SendBoolean (theEnt->TY());
+
+  theSW.SendBoolean (theEnt->TZ());
+
+  theSW.SendBoolean (theEnt->RX());
+
+  theSW.SendBoolean (theEnt->RY());
+
+  theSW.SendBoolean (theEnt->RZ());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWFullyConstrainedPair::Share (const Handle(StepKinematics_FullyConstrainedPair)& theEnt,
+                                                     Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of ItemDefinedTransformation
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Inherited fields of KinematicPair
+
+  iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+  // Inherited fields of LowOrderKinematicPair
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_FullyConstrainedPair;
+
+//! Read & Write tool for FullyConstrainedPair
+class RWStepKinematics_RWFullyConstrainedPair
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWFullyConstrainedPair();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_FullyConstrainedPair)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_FullyConstrainedPair)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_FullyConstrainedPair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWFullyConstrainedPair_HeaderFile_

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 <RWStepKinematics_RWGearPair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_GearPair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWGearPair
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWGearPair::RWStepKinematics_RWGearPair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWGearPair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                            const Standard_Integer theNum,
+                                            Handle(Interface_Check)& theArch,
+                                            const Handle(StepKinematics_GearPair)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,11,theArch,"gear_pair") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of ItemDefinedTransformation
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+  theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+  Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+  if ( theData->IsParamDefined (theNum,3) ) {
+    theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+  }
+  else {
+    hasItemDefinedTransformation_Description = Standard_False;
+    aItemDefinedTransformation_Description.Nullify();
+  }
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+  theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+  theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+  // Inherited fields of KinematicPair
+
+  Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+  theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+  // Own fields of GearPair
+
+  Standard_Real aRadiusFirstLink;
+  theData->ReadReal (theNum, 7, "radius_first_link", theArch, aRadiusFirstLink);
+
+  Standard_Real aRadiusSecondLink;
+  theData->ReadReal (theNum, 8, "radius_second_link", theArch, aRadiusSecondLink);
+
+  Standard_Real aBevel;
+  theData->ReadReal (theNum, 9, "bevel", theArch, aBevel);
+
+  Standard_Real aHelicalAngle;
+  theData->ReadReal (theNum, 10, "helical_angle", theArch, aHelicalAngle);
+
+  Standard_Real aGearRatio;
+  theData->ReadReal (theNum, 11, "gear_ratio", theArch, aGearRatio);
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aItemDefinedTransformation_Name,
+            hasItemDefinedTransformation_Description,
+            aItemDefinedTransformation_Description,
+            aItemDefinedTransformation_TransformItem1,
+            aItemDefinedTransformation_TransformItem2,
+            aKinematicPair_Joint,
+            aRadiusFirstLink,
+            aRadiusSecondLink,
+            aBevel,
+            aHelicalAngle,
+            aGearRatio);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWGearPair::WriteStep (StepData_StepWriter& theSW,
+                                             const Handle(StepKinematics_GearPair)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Inherited fields of ItemDefinedTransformation
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+  if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+    theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+  }
+  else theSW.SendUndef();
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Own fields of KinematicPair
+
+  theSW.Send (theEnt->Joint());
+
+  // Own fields of GearPair
+
+  theSW.Send (theEnt->RadiusFirstLink());
+
+  theSW.Send (theEnt->RadiusSecondLink());
+
+  theSW.Send (theEnt->Bevel());
+
+  theSW.Send (theEnt->HelicalAngle());
+
+  theSW.Send (theEnt->GearRatio());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWGearPair::Share (const Handle(StepKinematics_GearPair)& theEnt,
+                                         Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of ItemDefinedTransformation
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Inherited fields of KinematicPair
+
+  iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+  // Own fields of GearPair
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_GearPair;
+
+//! Read & Write tool for GearPair
+class RWStepKinematics_RWGearPair
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWGearPair();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_GearPair)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_GearPair)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_GearPair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWGearPair_HeaderFile_

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 <RWStepKinematics_RWGearPairValue.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_GearPairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWGearPairValue
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWGearPairValue::RWStepKinematics_RWGearPairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWGearPairValue::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                 const Standard_Integer theNum,
+                                                 Handle(Interface_Check)& theArch,
+                                                 const Handle(StepKinematics_GearPairValue)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,3,theArch,"gear_pair_value") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of PairValue
+
+  Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+  theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+  // Own fields of GearPairValue
+
+  Standard_Real aActualRotation1;
+  theData->ReadReal (theNum, 3, "actual_rotation1", theArch, aActualRotation1);
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aPairValue_AppliesToPair,
+            aActualRotation1);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWGearPairValue::WriteStep (StepData_StepWriter& theSW,
+                                                  const Handle(StepKinematics_GearPairValue)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Own fields of PairValue
+
+  theSW.Send (theEnt->AppliesToPair());
+
+  // Own fields of GearPairValue
+
+  theSW.Send (theEnt->ActualRotation1());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWGearPairValue::Share (const Handle(StepKinematics_GearPairValue)& theEnt,
+                                              Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of PairValue
+
+  iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair());
+
+  // Own fields of GearPairValue
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_GearPairValue;
+
+//! Read & Write tool for GearPairValue
+class RWStepKinematics_RWGearPairValue
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWGearPairValue();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_GearPairValue)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_GearPairValue)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_GearPairValue)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWGearPairValue_HeaderFile_

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 <RWStepKinematics_RWGearPairWithRange.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_GearPairWithRange.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWGearPairWithRange
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWGearPairWithRange::RWStepKinematics_RWGearPairWithRange() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWGearPairWithRange::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                     const Standard_Integer theNum,
+                                                     Handle(Interface_Check)& theArch,
+                                                     const Handle(StepKinematics_GearPairWithRange)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,13,theArch,"gear_pair_with_range") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of ItemDefinedTransformation
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+  theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+  Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+  if ( theData->IsParamDefined (theNum,3) ) {
+    theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+  }
+  else {
+    hasItemDefinedTransformation_Description = Standard_False;
+    aItemDefinedTransformation_Description.Nullify();
+  }
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+  theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+  theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+  // Inherited fields of KinematicPair
+
+  Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+  theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+  // Inherited fields of GearPair
+
+  Standard_Real aGearPair_RadiusFirstLink;
+  theData->ReadReal (theNum, 7, "gear_pair.radius_first_link", theArch, aGearPair_RadiusFirstLink);
+
+  Standard_Real aGearPair_RadiusSecondLink;
+  theData->ReadReal (theNum, 8, "gear_pair.radius_second_link", theArch, aGearPair_RadiusSecondLink);
+
+  Standard_Real aGearPair_Bevel;
+  theData->ReadReal (theNum, 9, "gear_pair.bevel", theArch, aGearPair_Bevel);
+
+  Standard_Real aGearPair_HelicalAngle;
+  theData->ReadReal (theNum, 10, "gear_pair.helical_angle", theArch, aGearPair_HelicalAngle);
+
+  Standard_Real aGearPair_GearRatio;
+  theData->ReadReal (theNum, 11, "gear_pair.gear_ratio", theArch, aGearPair_GearRatio);
+
+  // Own fields of GearPairWithRange
+
+  Standard_Real aLowerLimitActualRotation1;
+  Standard_Boolean hasLowerLimitActualRotation1 = Standard_True;
+  if ( theData->IsParamDefined (theNum,12) ) {
+    theData->ReadReal (theNum, 12, "lower_limit_actual_rotation1", theArch, aLowerLimitActualRotation1);
+  }
+  else {
+    hasLowerLimitActualRotation1 = Standard_False;
+    aLowerLimitActualRotation1 = 0;
+  }
+
+  Standard_Real aUpperLimitActualRotation1;
+  Standard_Boolean hasUpperLimitActualRotation1 = Standard_True;
+  if ( theData->IsParamDefined (theNum,13) ) {
+    theData->ReadReal (theNum, 13, "upper_limit_actual_rotation1", theArch, aUpperLimitActualRotation1);
+  }
+  else {
+    hasUpperLimitActualRotation1 = Standard_False;
+    aUpperLimitActualRotation1 = 0;
+  }
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aItemDefinedTransformation_Name,
+            hasItemDefinedTransformation_Description,
+            aItemDefinedTransformation_Description,
+            aItemDefinedTransformation_TransformItem1,
+            aItemDefinedTransformation_TransformItem2,
+            aKinematicPair_Joint,
+            aGearPair_RadiusFirstLink,
+            aGearPair_RadiusSecondLink,
+            aGearPair_Bevel,
+            aGearPair_HelicalAngle,
+            aGearPair_GearRatio,
+            hasLowerLimitActualRotation1,
+            aLowerLimitActualRotation1,
+            hasUpperLimitActualRotation1,
+            aUpperLimitActualRotation1);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWGearPairWithRange::WriteStep (StepData_StepWriter& theSW,
+                                                      const Handle(StepKinematics_GearPairWithRange)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Inherited fields of ItemDefinedTransformation
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+  if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+    theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+  }
+  else theSW.SendUndef();
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Own fields of KinematicPair
+
+  theSW.Send (theEnt->Joint());
+
+  // Own fields of GearPair
+
+  theSW.Send (theEnt->RadiusFirstLink());
+
+  theSW.Send (theEnt->RadiusSecondLink());
+
+  theSW.Send (theEnt->Bevel());
+
+  theSW.Send (theEnt->HelicalAngle());
+
+  theSW.Send (theEnt->GearRatio());
+
+  // Own fields of GearPairWithRange
+
+  if ( theEnt->HasLowerLimitActualRotation1() ) {
+    theSW.Send (theEnt->LowerLimitActualRotation1());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasUpperLimitActualRotation1() ) {
+    theSW.Send (theEnt->UpperLimitActualRotation1());
+  }
+  else theSW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWGearPairWithRange::Share (const Handle(StepKinematics_GearPairWithRange)& theEnt,
+                                                  Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of ItemDefinedTransformation
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Inherited fields of KinematicPair
+
+  iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+  // Inherited fields of GearPair
+
+  // Own fields of GearPairWithRange
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_GearPairWithRange;
+
+//! Read & Write tool for GearPairWithRange
+class RWStepKinematics_RWGearPairWithRange
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWGearPairWithRange();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_GearPairWithRange)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_GearPairWithRange)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_GearPairWithRange)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWGearPairWithRange_HeaderFile_

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 <RWStepKinematics_RWHomokineticPair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_HomokineticPair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWHomokineticPair
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWHomokineticPair::RWStepKinematics_RWHomokineticPair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWHomokineticPair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                   const Standard_Integer theNum,
+                                                   Handle(Interface_Check)& theArch,
+                                                   const Handle(StepKinematics_HomokineticPair)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,13,theArch,"homokinetic_pair") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of ItemDefinedTransformation
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+  theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+  Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+  if ( theData->IsParamDefined (theNum,3) ) {
+    theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+  }
+  else {
+    hasItemDefinedTransformation_Description = Standard_False;
+    aItemDefinedTransformation_Description.Nullify();
+  }
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+  theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+  theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+  // Inherited fields of KinematicPair
+
+  Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+  theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+  // Inherited fields of LowOrderKinematicPair
+
+  Standard_Boolean aLowOrderKinematicPair_TX;
+  theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX);
+
+  Standard_Boolean aLowOrderKinematicPair_TY;
+  theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY);
+
+  Standard_Boolean aLowOrderKinematicPair_TZ;
+  theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ);
+
+  Standard_Boolean aLowOrderKinematicPair_RX;
+  theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX);
+
+  Standard_Boolean aLowOrderKinematicPair_RY;
+  theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY);
+
+  Standard_Boolean aLowOrderKinematicPair_RZ;
+  theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ);
+
+  // Inherited fields of UniversalPair
+
+  Standard_Real aUniversalPair_InputSkewAngle;
+  Standard_Boolean hasUniversalPair_InputSkewAngle = Standard_True;
+  if ( theData->IsParamDefined (theNum,13) ) {
+    theData->ReadReal (theNum, 13, "universal_pair.input_skew_angle", theArch, aUniversalPair_InputSkewAngle);
+  }
+  else {
+    hasUniversalPair_InputSkewAngle = Standard_False;
+    aUniversalPair_InputSkewAngle = 0;
+  }
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aItemDefinedTransformation_Name,
+            hasItemDefinedTransformation_Description,
+            aItemDefinedTransformation_Description,
+            aItemDefinedTransformation_TransformItem1,
+            aItemDefinedTransformation_TransformItem2,
+            aKinematicPair_Joint,
+            aLowOrderKinematicPair_TX,
+            aLowOrderKinematicPair_TY,
+            aLowOrderKinematicPair_TZ,
+            aLowOrderKinematicPair_RX,
+            aLowOrderKinematicPair_RY,
+            aLowOrderKinematicPair_RZ,
+            hasUniversalPair_InputSkewAngle,
+            aUniversalPair_InputSkewAngle);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWHomokineticPair::WriteStep (StepData_StepWriter& theSW,
+                                                    const Handle(StepKinematics_HomokineticPair)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Inherited fields of ItemDefinedTransformation
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+  if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+    theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+  }
+  else theSW.SendUndef();
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Own fields of KinematicPair
+
+  theSW.Send (theEnt->Joint());
+
+  // Own fields of LowOrderKinematicPair
+
+  theSW.SendBoolean (theEnt->TX());
+
+  theSW.SendBoolean (theEnt->TY());
+
+  theSW.SendBoolean (theEnt->TZ());
+
+  theSW.SendBoolean (theEnt->RX());
+
+  theSW.SendBoolean (theEnt->RY());
+
+  theSW.SendBoolean (theEnt->RZ());
+
+  // Own fields of UniversalPair
+
+  if ( theEnt->HasInputSkewAngle() ) {
+    theSW.Send (theEnt->InputSkewAngle());
+  }
+  else theSW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWHomokineticPair::Share (const Handle(StepKinematics_HomokineticPair)& theEnt,
+                                                Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of ItemDefinedTransformation
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Inherited fields of KinematicPair
+
+  iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+  // Inherited fields of LowOrderKinematicPair
+
+  // Inherited fields of UniversalPair
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_HomokineticPair;
+
+//! Read & Write tool for HomokineticPair
+class RWStepKinematics_RWHomokineticPair
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWHomokineticPair();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_HomokineticPair)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_HomokineticPair)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_HomokineticPair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWHomokineticPair_HeaderFile_

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 <RWStepKinematics_RWKinematicJoint.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepShape_Vertex.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWKinematicJoint
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWKinematicJoint::RWStepKinematics_RWKinematicJoint() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWKinematicJoint::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                  const Standard_Integer theNum,
+                                                  Handle(Interface_Check)& theArch,
+                                                  const Handle(StepKinematics_KinematicJoint)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,3,theArch,"kinematic_joint") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of Edge
+
+  Handle(StepShape_Vertex) aEdge_EdgeStart;
+  theData->ReadEntity (theNum, 2, "edge.edge_start", theArch, STANDARD_TYPE(StepShape_Vertex), aEdge_EdgeStart);
+
+  Handle(StepShape_Vertex) aEdge_EdgeEnd;
+  theData->ReadEntity (theNum, 3, "edge.edge_end", theArch, STANDARD_TYPE(StepShape_Vertex), aEdge_EdgeEnd);
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aEdge_EdgeStart,
+            aEdge_EdgeEnd);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWKinematicJoint::WriteStep (StepData_StepWriter& theSW,
+                                                   const Handle(StepKinematics_KinematicJoint)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Own fields of Edge
+
+  theSW.Send (theEnt->EdgeStart());
+
+  theSW.Send (theEnt->EdgeEnd());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWKinematicJoint::Share (const Handle(StepKinematics_KinematicJoint)& theEnt,
+                                               Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of Edge
+
+  iter.AddItem (theEnt->StepShape_Edge::EdgeStart());
+
+  iter.AddItem (theEnt->StepShape_Edge::EdgeEnd());
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_KinematicJoint;
+
+//! Read & Write tool for KinematicJoint
+class RWStepKinematics_RWKinematicJoint
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWKinematicJoint();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_KinematicJoint)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_KinematicJoint)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_KinematicJoint)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWKinematicJoint_HeaderFile_

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 <RWStepKinematics_RWKinematicLink.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_KinematicLink.hxx>
+#include <TCollection_HAsciiString.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWKinematicLink
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWKinematicLink::RWStepKinematics_RWKinematicLink() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWKinematicLink::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                 const Standard_Integer theNum,
+                                                 Handle(Interface_Check)& theArch,
+                                                 const Handle(StepKinematics_KinematicLink)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,1,theArch,"kinematic_link") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWKinematicLink::WriteStep (StepData_StepWriter& theSW,
+                                                  const Handle(StepKinematics_KinematicLink)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWKinematicLink::Share (const Handle(StepKinematics_KinematicLink)& /*theEnt*/,
+                                              Interface_EntityIterator& /*iter*/) const
+{
+
+  // Inherited fields of RepresentationItem
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_KinematicLink;
+
+//! Read & Write tool for KinematicLink
+class RWStepKinematics_RWKinematicLink
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWKinematicLink();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_KinematicLink)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_KinematicLink)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_KinematicLink)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWKinematicLink_HeaderFile_

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 <RWStepKinematics_RWKinematicLinkRepresentationAssociation.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_KinematicLinkRepresentationAssociation.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_Representation.hxx>
+#include <StepRepr_RepresentationOrRepresentationReference.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWKinematicLinkRepresentationAssociation
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWKinematicLinkRepresentationAssociation::RWStepKinematics_RWKinematicLinkRepresentationAssociation() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWKinematicLinkRepresentationAssociation::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                                          const Standard_Integer theNum,
+                                                                          Handle(Interface_Check)& theArch,
+                                                                          const Handle(StepKinematics_KinematicLinkRepresentationAssociation)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,4,theArch,"kinematic_link_representation_association") ) return;
+
+  // Inherited fields of RepresentationRelationship
+
+  Handle(TCollection_HAsciiString) aRepresentationRelationship_Name;
+  theData->ReadString (theNum, 1, "representation_relationship.name", theArch, aRepresentationRelationship_Name);
+
+  Handle(TCollection_HAsciiString) aRepresentationRelationship_Description;
+  if ( theData->IsParamDefined (theNum,2) ) {
+    theData->ReadString (theNum, 2, "representation_relationship.description", theArch, aRepresentationRelationship_Description);
+  }
+  else {
+    aRepresentationRelationship_Description.Nullify();
+  }
+
+  StepRepr_RepresentationOrRepresentationReference aRepresentationRelationship_Rep1;
+  theData->ReadEntity (theNum, 3, "representation_relationship.rep1", theArch, aRepresentationRelationship_Rep1);
+
+  StepRepr_RepresentationOrRepresentationReference aRepresentationRelationship_Rep2;
+  theData->ReadEntity (theNum, 4, "representation_relationship.rep2", theArch, aRepresentationRelationship_Rep2);
+
+  // Process only one type (Representaion)
+  if (aRepresentationRelationship_Rep1.CaseNumber() != 1 || aRepresentationRelationship_Rep1.CaseNumber() != 1)
+    return;
+
+  // Initialize entity
+  theEnt->Init(aRepresentationRelationship_Name,
+            aRepresentationRelationship_Description,
+            aRepresentationRelationship_Rep1.Representation(),
+            aRepresentationRelationship_Rep2.Representation());
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWKinematicLinkRepresentationAssociation::WriteStep (StepData_StepWriter& theSW,
+                                                                           const Handle(StepKinematics_KinematicLinkRepresentationAssociation)& theEnt) const
+{
+
+  // Own fields of RepresentationRelationship
+
+  theSW.Send (theEnt->Name());
+
+  if ( theEnt->HasDescription() ) {
+    theSW.Send (theEnt->Description());
+  }
+  else theSW.SendUndef();
+
+  theSW.Send (theEnt->Rep1());
+
+  theSW.Send (theEnt->Rep2());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWKinematicLinkRepresentationAssociation::Share (const Handle(StepKinematics_KinematicLinkRepresentationAssociation)& theEnt,
+                                                                       Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationRelationship
+
+  iter.AddItem (theEnt->StepRepr_RepresentationRelationship::Rep1());
+
+  iter.AddItem (theEnt->StepRepr_RepresentationRelationship::Rep2());
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_KinematicLinkRepresentationAssociation;
+
+//! Read & Write tool for KinematicLinkRepresentationAssociation
+class RWStepKinematics_RWKinematicLinkRepresentationAssociation
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWKinematicLinkRepresentationAssociation();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_KinematicLinkRepresentationAssociation)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_KinematicLinkRepresentationAssociation)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_KinematicLinkRepresentationAssociation)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWKinematicLinkRepresentationAssociation_HeaderFile_

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 <RWStepKinematics_RWKinematicPropertyMechanismRepresentation.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_KinematicPropertyMechanismRepresentation.hxx>
+#include <StepRepr_RepresentedDefinition.hxx>
+#include <StepRepr_Representation.hxx>
+#include <StepKinematics_KinematicLinkRepresentation.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWKinematicPropertyMechanismRepresentation
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWKinematicPropertyMechanismRepresentation::RWStepKinematics_RWKinematicPropertyMechanismRepresentation() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWKinematicPropertyMechanismRepresentation::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                                            const Standard_Integer theNum,
+                                                                            Handle(Interface_Check)& theArch,
+                                                                            const Handle(StepKinematics_KinematicPropertyMechanismRepresentation)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,3,theArch,"kinematic_property_mechanism_representation") ) return;
+
+  // Inherited fields of PropertyDefinitionRepresentation
+
+  StepRepr_RepresentedDefinition aPropertyDefinitionRepresentation_Definition;
+  theData->ReadEntity (theNum, 1, "property_definition_representation.definition", theArch, aPropertyDefinitionRepresentation_Definition);
+
+  Handle(StepRepr_Representation) aPropertyDefinitionRepresentation_UsedRepresentation;
+  theData->ReadEntity (theNum, 2, "property_definition_representation.used_representation", theArch, STANDARD_TYPE(StepRepr_Representation), aPropertyDefinitionRepresentation_UsedRepresentation);
+
+  // Own fields of KinematicPropertyMechanismRepresentation
+
+  Handle(StepKinematics_KinematicLinkRepresentation) aBase;
+  theData->ReadEntity (theNum, 3, "base", theArch, STANDARD_TYPE(StepKinematics_KinematicLinkRepresentation), aBase);
+
+  // Initialize entity
+  theEnt->Init(aPropertyDefinitionRepresentation_Definition,
+            aPropertyDefinitionRepresentation_UsedRepresentation,
+            aBase);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWKinematicPropertyMechanismRepresentation::WriteStep (StepData_StepWriter& theSW,
+                                                                             const Handle(StepKinematics_KinematicPropertyMechanismRepresentation)& theEnt) const
+{
+
+  // Own fields of PropertyDefinitionRepresentation
+
+  theSW.Send (theEnt->Definition().Value());
+
+  theSW.Send (theEnt->UsedRepresentation());
+
+  // Own fields of KinematicPropertyMechanismRepresentation
+
+  theSW.Send (theEnt->Base());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWKinematicPropertyMechanismRepresentation::Share (const Handle(StepKinematics_KinematicPropertyMechanismRepresentation)& theEnt,
+                                                                         Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of PropertyDefinitionRepresentation
+
+  iter.AddItem (theEnt->StepRepr_PropertyDefinitionRepresentation::Definition().Value());
+
+  iter.AddItem (theEnt->StepRepr_PropertyDefinitionRepresentation::UsedRepresentation());
+
+  // Own fields of KinematicPropertyMechanismRepresentation
+
+  iter.AddItem (theEnt->Base());
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_KinematicPropertyMechanismRepresentation;
+
+//! Read & Write tool for KinematicPropertyMechanismRepresentation
+class RWStepKinematics_RWKinematicPropertyMechanismRepresentation
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWKinematicPropertyMechanismRepresentation();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_KinematicPropertyMechanismRepresentation)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_KinematicPropertyMechanismRepresentation)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_KinematicPropertyMechanismRepresentation)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWKinematicPropertyMechanismRepresentation_HeaderFile_

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 <RWStepKinematics_RWKinematicTopologyDirectedStructure.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_KinematicTopologyDirectedStructure.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_RepresentationContext.hxx>
+#include <StepKinematics_KinematicTopologyStructure.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWKinematicTopologyDirectedStructure
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWKinematicTopologyDirectedStructure::RWStepKinematics_RWKinematicTopologyDirectedStructure() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWKinematicTopologyDirectedStructure::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                                      const Standard_Integer theNum,
+                                                                      Handle(Interface_Check)& theArch,
+                                                                      const Handle(StepKinematics_KinematicTopologyDirectedStructure)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,4,theArch,"kinematic_topology_directed_structure") ) return;
+
+  // Inherited fields of Representation
+
+  Handle(TCollection_HAsciiString) aRepresentation_Name;
+  theData->ReadString (theNum, 1, "representation.name", theArch, aRepresentation_Name);
+
+  Handle(StepRepr_HArray1OfRepresentationItem) aRepresentation_Items;
+  Standard_Integer sub2 = 0;
+  if ( theData->ReadSubList (theNum, 2, "representation.items", theArch, sub2) ) {
+    Standard_Integer nb0 = theData->NbParams(sub2);
+    aRepresentation_Items = new StepRepr_HArray1OfRepresentationItem (1, nb0);
+    Standard_Integer num2 = sub2;
+    for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
+      Handle(StepRepr_RepresentationItem) anIt0;
+      theData->ReadEntity (num2, i0, "representation_item", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), anIt0);
+      aRepresentation_Items->SetValue(i0, anIt0);
+    }
+  }
+
+  Handle(StepRepr_RepresentationContext) aRepresentation_ContextOfItems;
+  theData->ReadEntity (theNum, 3, "representation.context_of_items", theArch, STANDARD_TYPE(StepRepr_RepresentationContext), aRepresentation_ContextOfItems);
+
+  // Own fields of KinematicTopologyDirectedStructure
+
+  Handle(StepKinematics_KinematicTopologyStructure) aParent;
+  theData->ReadEntity (theNum, 4, "parent", theArch, STANDARD_TYPE(StepKinematics_KinematicTopologyStructure), aParent);
+
+  // Initialize entity
+  theEnt->Init(aRepresentation_Name,
+            aRepresentation_Items,
+            aRepresentation_ContextOfItems,
+            aParent);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWKinematicTopologyDirectedStructure::WriteStep (StepData_StepWriter& theSW,
+                                                                       const Handle(StepKinematics_KinematicTopologyDirectedStructure)& theEnt) const
+{
+
+  // Own fields of Representation
+
+  theSW.Send (theEnt->Name());
+
+  theSW.OpenSub();
+  for (Standard_Integer i1=1; i1 <= theEnt->Items()->Length(); i1++ ) {
+    Handle(StepRepr_RepresentationItem) Var0 = theEnt->Items()->Value(i1);
+    theSW.Send (Var0);
+  }
+  theSW.CloseSub();
+
+  theSW.Send (theEnt->ContextOfItems());
+
+  // Own fields of KinematicTopologyDirectedStructure
+
+  theSW.Send (theEnt->Parent());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWKinematicTopologyDirectedStructure::Share (const Handle(StepKinematics_KinematicTopologyDirectedStructure)& theEnt,
+                                                                   Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of Representation
+
+  for (Standard_Integer i1=1; i1 <= theEnt->StepRepr_Representation::Items()->Length(); i1++ ) {
+    Handle(StepRepr_RepresentationItem) Var0 = theEnt->StepRepr_Representation::Items()->Value(i1);
+    iter.AddItem (Var0);
+  }
+
+  iter.AddItem (theEnt->StepRepr_Representation::ContextOfItems());
+
+  // Own fields of KinematicTopologyDirectedStructure
+
+  iter.AddItem (theEnt->Parent());
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_KinematicTopologyDirectedStructure;
+
+//! Read & Write tool for KinematicTopologyDirectedStructure
+class RWStepKinematics_RWKinematicTopologyDirectedStructure
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWKinematicTopologyDirectedStructure();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_KinematicTopologyDirectedStructure)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_KinematicTopologyDirectedStructure)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_KinematicTopologyDirectedStructure)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWKinematicTopologyDirectedStructure_HeaderFile_

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 <RWStepKinematics_RWKinematicTopologyNetworkStructure.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_KinematicTopologyNetworkStructure.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_RepresentationContext.hxx>
+#include <StepKinematics_KinematicTopologyStructure.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWKinematicTopologyNetworkStructure
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWKinematicTopologyNetworkStructure::RWStepKinematics_RWKinematicTopologyNetworkStructure() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWKinematicTopologyNetworkStructure::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                                     const Standard_Integer theNum,
+                                                                     Handle(Interface_Check)& theArch,
+                                                                     const Handle(StepKinematics_KinematicTopologyNetworkStructure)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,4,theArch,"kinematic_topology_network_structure") ) return;
+
+  // Inherited fields of Representation
+
+  Handle(TCollection_HAsciiString) aRepresentation_Name;
+  theData->ReadString (theNum, 1, "representation.name", theArch, aRepresentation_Name);
+
+  Handle(StepRepr_HArray1OfRepresentationItem) aRepresentation_Items;
+  Standard_Integer sub2 = 0;
+  if ( theData->ReadSubList (theNum, 2, "representation.items", theArch, sub2) ) {
+    Standard_Integer nb0 = theData->NbParams(sub2);
+    aRepresentation_Items = new StepRepr_HArray1OfRepresentationItem (1, nb0);
+    Standard_Integer num2 = sub2;
+    for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
+      Handle(StepRepr_RepresentationItem) anIt0;
+      theData->ReadEntity (num2, i0, "representation_item", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), anIt0);
+      aRepresentation_Items->SetValue(i0, anIt0);
+    }
+  }
+
+  Handle(StepRepr_RepresentationContext) aRepresentation_ContextOfItems;
+  theData->ReadEntity (theNum, 3, "representation.context_of_items", theArch, STANDARD_TYPE(StepRepr_RepresentationContext), aRepresentation_ContextOfItems);
+
+  // Own fields of KinematicTopologyNetworkStructure
+
+  Handle(StepKinematics_KinematicTopologyStructure) aParent;
+  theData->ReadEntity (theNum, 4, "parent", theArch, STANDARD_TYPE(StepKinematics_KinematicTopologyStructure), aParent);
+
+  // Initialize entity
+  theEnt->Init(aRepresentation_Name,
+            aRepresentation_Items,
+            aRepresentation_ContextOfItems,
+            aParent);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWKinematicTopologyNetworkStructure::WriteStep (StepData_StepWriter& theSW,
+                                                                      const Handle(StepKinematics_KinematicTopologyNetworkStructure)& theEnt) const
+{
+
+  // Own fields of Representation
+
+  theSW.Send (theEnt->Name());
+
+  theSW.OpenSub();
+  for (Standard_Integer i1=1; i1 <= theEnt->Items()->Length(); i1++ ) {
+    Handle(StepRepr_RepresentationItem) Var0 = theEnt->Items()->Value(i1);
+    theSW.Send (Var0);
+  }
+  theSW.CloseSub();
+
+  theSW.Send (theEnt->ContextOfItems());
+
+  // Own fields of KinematicTopologyNetworkStructure
+
+  theSW.Send (theEnt->Parent());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWKinematicTopologyNetworkStructure::Share (const Handle(StepKinematics_KinematicTopologyNetworkStructure)& theEnt,
+                                                                  Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of Representation
+
+  for (Standard_Integer i1=1; i1 <= theEnt->StepRepr_Representation::Items()->Length(); i1++ ) {
+    Handle(StepRepr_RepresentationItem) Var0 = theEnt->StepRepr_Representation::Items()->Value(i1);
+    iter.AddItem (Var0);
+  }
+
+  iter.AddItem (theEnt->StepRepr_Representation::ContextOfItems());
+
+  // Own fields of KinematicTopologyNetworkStructure
+
+  iter.AddItem (theEnt->Parent());
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_KinematicTopologyNetworkStructure;
+
+//! Read & Write tool for KinematicTopologyNetworkStructure
+class RWStepKinematics_RWKinematicTopologyNetworkStructure
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWKinematicTopologyNetworkStructure();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_KinematicTopologyNetworkStructure)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_KinematicTopologyNetworkStructure)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_KinematicTopologyNetworkStructure)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWKinematicTopologyNetworkStructure_HeaderFile_

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 <RWStepKinematics_RWKinematicTopologyStructure.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_KinematicTopologyStructure.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_RepresentationContext.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWKinematicTopologyStructure
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWKinematicTopologyStructure::RWStepKinematics_RWKinematicTopologyStructure() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWKinematicTopologyStructure::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                              const Standard_Integer theNum,
+                                                              Handle(Interface_Check)& theArch,
+                                                              const Handle(StepKinematics_KinematicTopologyStructure)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,3,theArch,"kinematic_topology_structure") ) return;
+
+  // Inherited fields of Representation
+
+  Handle(TCollection_HAsciiString) aRepresentation_Name;
+  theData->ReadString (theNum, 1, "representation.name", theArch, aRepresentation_Name);
+
+  Handle(StepRepr_HArray1OfRepresentationItem) aRepresentation_Items;
+  Standard_Integer sub2 = 0;
+  if ( theData->ReadSubList (theNum, 2, "representation.items", theArch, sub2) ) {
+    Standard_Integer nb0 = theData->NbParams(sub2);
+    aRepresentation_Items = new StepRepr_HArray1OfRepresentationItem (1, nb0);
+    Standard_Integer num2 = sub2;
+    for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
+      Handle(StepRepr_RepresentationItem) anIt0;
+      theData->ReadEntity (num2, i0, "representation_item", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), anIt0);
+      aRepresentation_Items->SetValue(i0, anIt0);
+    }
+  }
+
+  Handle(StepRepr_RepresentationContext) aRepresentation_ContextOfItems;
+  theData->ReadEntity (theNum, 3, "representation.context_of_items", theArch, STANDARD_TYPE(StepRepr_RepresentationContext), aRepresentation_ContextOfItems);
+
+  // Initialize entity
+  theEnt->Init(aRepresentation_Name,
+            aRepresentation_Items,
+            aRepresentation_ContextOfItems);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWKinematicTopologyStructure::WriteStep (StepData_StepWriter& theSW,
+                                                               const Handle(StepKinematics_KinematicTopologyStructure)& theEnt) const
+{
+
+  // Own fields of Representation
+
+  theSW.Send (theEnt->Name());
+
+  theSW.OpenSub();
+  for (Standard_Integer i1=1; i1 <= theEnt->Items()->Length(); i1++ ) {
+    Handle(StepRepr_RepresentationItem) Var0 = theEnt->Items()->Value(i1);
+    theSW.Send (Var0);
+  }
+  theSW.CloseSub();
+
+  theSW.Send (theEnt->ContextOfItems());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWKinematicTopologyStructure::Share (const Handle(StepKinematics_KinematicTopologyStructure)& theEnt,
+                                                           Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of Representation
+
+  for (Standard_Integer i1=1; i1 <= theEnt->StepRepr_Representation::Items()->Length(); i1++ ) {
+    Handle(StepRepr_RepresentationItem) Var0 = theEnt->StepRepr_Representation::Items()->Value(i1);
+    iter.AddItem (Var0);
+  }
+
+  iter.AddItem (theEnt->StepRepr_Representation::ContextOfItems());
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_KinematicTopologyStructure;
+
+//! Read & Write tool for KinematicTopologyStructure
+class RWStepKinematics_RWKinematicTopologyStructure
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWKinematicTopologyStructure();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_KinematicTopologyStructure)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_KinematicTopologyStructure)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_KinematicTopologyStructure)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWKinematicTopologyStructure_HeaderFile_

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 <RWStepKinematics_RWLinearFlexibleAndPinionPair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_LinearFlexibleAndPinionPair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWLinearFlexibleAndPinionPair
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWLinearFlexibleAndPinionPair::RWStepKinematics_RWLinearFlexibleAndPinionPair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWLinearFlexibleAndPinionPair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                               const Standard_Integer theNum,
+                                                               Handle(Interface_Check)& theArch,
+                                                               const Handle(StepKinematics_LinearFlexibleAndPinionPair)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,7,theArch,"linear_flexible_and_pinion_pair") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of ItemDefinedTransformation
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+  theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+  Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+  if ( theData->IsParamDefined (theNum,3) ) {
+    theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+  }
+  else {
+    hasItemDefinedTransformation_Description = Standard_False;
+    aItemDefinedTransformation_Description.Nullify();
+  }
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+  theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+  theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+  // Inherited fields of KinematicPair
+
+  Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+  theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+  // Own fields of LinearFlexibleAndPinionPair
+
+  Standard_Real aPinionRadius;
+  theData->ReadReal (theNum, 7, "pinion_radius", theArch, aPinionRadius);
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aItemDefinedTransformation_Name,
+            hasItemDefinedTransformation_Description,
+            aItemDefinedTransformation_Description,
+            aItemDefinedTransformation_TransformItem1,
+            aItemDefinedTransformation_TransformItem2,
+            aKinematicPair_Joint,
+            aPinionRadius);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWLinearFlexibleAndPinionPair::WriteStep (StepData_StepWriter& theSW,
+                                                                const Handle(StepKinematics_LinearFlexibleAndPinionPair)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Inherited fields of ItemDefinedTransformation
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+  if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+    theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+  }
+  else theSW.SendUndef();
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Own fields of KinematicPair
+
+  theSW.Send (theEnt->Joint());
+
+  // Own fields of LinearFlexibleAndPinionPair
+
+  theSW.Send (theEnt->PinionRadius());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWLinearFlexibleAndPinionPair::Share (const Handle(StepKinematics_LinearFlexibleAndPinionPair)& theEnt,
+                                                            Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of ItemDefinedTransformation
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Inherited fields of KinematicPair
+
+  iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+  // Own fields of LinearFlexibleAndPinionPair
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_LinearFlexibleAndPinionPair;
+
+//! Read & Write tool for LinearFlexibleAndPinionPair
+class RWStepKinematics_RWLinearFlexibleAndPinionPair
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWLinearFlexibleAndPinionPair();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_LinearFlexibleAndPinionPair)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_LinearFlexibleAndPinionPair)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_LinearFlexibleAndPinionPair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWLinearFlexibleAndPinionPair_HeaderFile_

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 <RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_LinearFlexibleAndPlanarCurvePair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Curve.hxx>
+#include <Standard_Boolean.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair::RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                                    const Standard_Integer theNum,
+                                                                    Handle(Interface_Check)& theArch,
+                                                                    const Handle(StepKinematics_LinearFlexibleAndPlanarCurvePair)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,8,theArch,"linear_flexible_and_planar_curve_pair") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of ItemDefinedTransformation
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+  theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+  Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+  if ( theData->IsParamDefined (theNum,3) ) {
+    theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+  }
+  else {
+    hasItemDefinedTransformation_Description = Standard_False;
+    aItemDefinedTransformation_Description.Nullify();
+  }
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+  theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+  theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+  // Inherited fields of KinematicPair
+
+  Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+  theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+  // Own fields of LinearFlexibleAndPlanarCurvePair
+
+  Handle(StepGeom_Curve) aPairCurve;
+  theData->ReadEntity (theNum, 7, "pair_curve", theArch, STANDARD_TYPE(StepGeom_Curve), aPairCurve);
+
+  Standard_Boolean aOrientation;
+  theData->ReadBoolean (theNum, 8, "orientation", theArch, aOrientation);
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aItemDefinedTransformation_Name,
+            hasItemDefinedTransformation_Description,
+            aItemDefinedTransformation_Description,
+            aItemDefinedTransformation_TransformItem1,
+            aItemDefinedTransformation_TransformItem2,
+            aKinematicPair_Joint,
+            aPairCurve,
+            aOrientation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair::WriteStep (StepData_StepWriter& theSW,
+                                                                     const Handle(StepKinematics_LinearFlexibleAndPlanarCurvePair)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Inherited fields of ItemDefinedTransformation
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+  if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+    theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+  }
+  else theSW.SendUndef();
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Own fields of KinematicPair
+
+  theSW.Send (theEnt->Joint());
+
+  // Own fields of LinearFlexibleAndPlanarCurvePair
+
+  theSW.Send (theEnt->PairCurve());
+
+  theSW.SendBoolean (theEnt->Orientation());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair::Share (const Handle(StepKinematics_LinearFlexibleAndPlanarCurvePair)& theEnt,
+                                                                 Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of ItemDefinedTransformation
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Inherited fields of KinematicPair
+
+  iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+  // Own fields of LinearFlexibleAndPlanarCurvePair
+
+  iter.AddItem (theEnt->PairCurve());
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_LinearFlexibleAndPlanarCurvePair;
+
+//! Read & Write tool for LinearFlexibleAndPlanarCurvePair
+class RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_LinearFlexibleAndPlanarCurvePair)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_LinearFlexibleAndPlanarCurvePair)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_LinearFlexibleAndPlanarCurvePair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair_HeaderFile_

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 <RWStepKinematics_RWLinearFlexibleLinkRepresentation.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_LinearFlexibleLinkRepresentation.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_RepresentationContext.hxx>
+#include <StepKinematics_KinematicLink.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWLinearFlexibleLinkRepresentation
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWLinearFlexibleLinkRepresentation::RWStepKinematics_RWLinearFlexibleLinkRepresentation() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWLinearFlexibleLinkRepresentation::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                                    const Standard_Integer theNum,
+                                                                    Handle(Interface_Check)& theArch,
+                                                                    const Handle(StepKinematics_LinearFlexibleLinkRepresentation)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,4,theArch,"linear_flexible_link_representation") ) return;
+
+  // Inherited fields of Representation
+
+  Handle(TCollection_HAsciiString) aRepresentation_Name;
+  theData->ReadString (theNum, 1, "representation.name", theArch, aRepresentation_Name);
+
+  Handle(StepRepr_HArray1OfRepresentationItem) aRepresentation_Items;
+  Standard_Integer sub2 = 0;
+  if ( theData->ReadSubList (theNum, 2, "representation.items", theArch, sub2) ) {
+    Standard_Integer nb0 = theData->NbParams(sub2);
+    aRepresentation_Items = new StepRepr_HArray1OfRepresentationItem (1, nb0);
+    Standard_Integer num2 = sub2;
+    for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
+      Handle(StepRepr_RepresentationItem) anIt0;
+      theData->ReadEntity (num2, i0, "representation_item", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), anIt0);
+      aRepresentation_Items->SetValue(i0, anIt0);
+    }
+  }
+
+  Handle(StepRepr_RepresentationContext) aRepresentation_ContextOfItems;
+  theData->ReadEntity (theNum, 3, "representation.context_of_items", theArch, STANDARD_TYPE(StepRepr_RepresentationContext), aRepresentation_ContextOfItems);
+
+  // Inherited fields of KinematicLinkRepresentation
+
+  Handle(StepKinematics_KinematicLink) aKinematicLinkRepresentation_RepresentedLink;
+  theData->ReadEntity (theNum, 4, "kinematic_link_representation.represented_link", theArch, STANDARD_TYPE(StepKinematics_KinematicLink), aKinematicLinkRepresentation_RepresentedLink);
+
+  // Initialize entity
+  theEnt->Init(aRepresentation_Name,
+            aRepresentation_Items,
+            aRepresentation_ContextOfItems,
+            aKinematicLinkRepresentation_RepresentedLink);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWLinearFlexibleLinkRepresentation::WriteStep (StepData_StepWriter& theSW,
+                                                                     const Handle(StepKinematics_LinearFlexibleLinkRepresentation)& theEnt) const
+{
+
+  // Own fields of Representation
+
+  theSW.Send (theEnt->Name());
+
+  theSW.OpenSub();
+  for (Standard_Integer i1=1; i1 <= theEnt->Items()->Length(); i1++ ) {
+    Handle(StepRepr_RepresentationItem) Var0 = theEnt->Items()->Value(i1);
+    theSW.Send (Var0);
+  }
+  theSW.CloseSub();
+
+  theSW.Send (theEnt->ContextOfItems());
+
+  // Own fields of KinematicLinkRepresentation
+
+  theSW.Send (theEnt->RepresentedLink());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWLinearFlexibleLinkRepresentation::Share (const Handle(StepKinematics_LinearFlexibleLinkRepresentation)& theEnt,
+                                                                 Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of Representation
+
+  for (Standard_Integer i1=1; i1 <= theEnt->StepRepr_Representation::Items()->Length(); i1++ ) {
+    Handle(StepRepr_RepresentationItem) Var0 = theEnt->StepRepr_Representation::Items()->Value(i1);
+    iter.AddItem (Var0);
+  }
+
+  iter.AddItem (theEnt->StepRepr_Representation::ContextOfItems());
+
+  // Inherited fields of KinematicLinkRepresentation
+
+  iter.AddItem (theEnt->StepKinematics_KinematicLinkRepresentation::RepresentedLink());
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_LinearFlexibleLinkRepresentation;
+
+//! Read & Write tool for LinearFlexibleLinkRepresentation
+class RWStepKinematics_RWLinearFlexibleLinkRepresentation
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWLinearFlexibleLinkRepresentation();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_LinearFlexibleLinkRepresentation)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_LinearFlexibleLinkRepresentation)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_LinearFlexibleLinkRepresentation)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWLinearFlexibleLinkRepresentation_HeaderFile_

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 <RWStepKinematics_RWLowOrderKinematicPair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_LowOrderKinematicPair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWLowOrderKinematicPair
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWLowOrderKinematicPair::RWStepKinematics_RWLowOrderKinematicPair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWLowOrderKinematicPair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                         const Standard_Integer theNum,
+                                                         Handle(Interface_Check)& theArch,
+                                                         const Handle(StepKinematics_LowOrderKinematicPair)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,12,theArch,"low_order_kinematic_pair") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of ItemDefinedTransformation
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+  theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+  Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+  if ( theData->IsParamDefined (theNum,3) ) {
+    theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+  }
+  else {
+    hasItemDefinedTransformation_Description = Standard_False;
+    aItemDefinedTransformation_Description.Nullify();
+  }
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+  theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+  theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+  // Inherited fields of KinematicPair
+
+  Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+  theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+  // Own fields of LowOrderKinematicPair
+
+  Standard_Boolean aTX;
+  theData->ReadBoolean (theNum, 7, "t_x", theArch, aTX);
+
+  Standard_Boolean aTY;
+  theData->ReadBoolean (theNum, 8, "t_y", theArch, aTY);
+
+  Standard_Boolean aTZ;
+  theData->ReadBoolean (theNum, 9, "t_z", theArch, aTZ);
+
+  Standard_Boolean aRX;
+  theData->ReadBoolean (theNum, 10, "r_x", theArch, aRX);
+
+  Standard_Boolean aRY;
+  theData->ReadBoolean (theNum, 11, "r_y", theArch, aRY);
+
+  Standard_Boolean aRZ;
+  theData->ReadBoolean (theNum, 12, "r_z", theArch, aRZ);
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aItemDefinedTransformation_Name,
+            hasItemDefinedTransformation_Description,
+            aItemDefinedTransformation_Description,
+            aItemDefinedTransformation_TransformItem1,
+            aItemDefinedTransformation_TransformItem2,
+            aKinematicPair_Joint,
+            aTX,
+            aTY,
+            aTZ,
+            aRX,
+            aRY,
+            aRZ);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWLowOrderKinematicPair::WriteStep (StepData_StepWriter& theSW,
+                                                          const Handle(StepKinematics_LowOrderKinematicPair)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Inherited fields of ItemDefinedTransformation
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+  if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+    theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+  }
+  else theSW.SendUndef();
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Own fields of KinematicPair
+
+  theSW.Send (theEnt->Joint());
+
+  // Own fields of LowOrderKinematicPair
+
+  theSW.SendBoolean (theEnt->TX());
+
+  theSW.SendBoolean (theEnt->TY());
+
+  theSW.SendBoolean (theEnt->TZ());
+
+  theSW.SendBoolean (theEnt->RX());
+
+  theSW.SendBoolean (theEnt->RY());
+
+  theSW.SendBoolean (theEnt->RZ());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWLowOrderKinematicPair::Share (const Handle(StepKinematics_LowOrderKinematicPair)& theEnt,
+                                                      Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of ItemDefinedTransformation
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Inherited fields of KinematicPair
+
+  iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+  // Own fields of LowOrderKinematicPair
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_LowOrderKinematicPair;
+
+//! Read & Write tool for LowOrderKinematicPair
+class RWStepKinematics_RWLowOrderKinematicPair
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWLowOrderKinematicPair();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_LowOrderKinematicPair)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_LowOrderKinematicPair)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_LowOrderKinematicPair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWLowOrderKinematicPair_HeaderFile_

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 <RWStepKinematics_RWLowOrderKinematicPairValue.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_LowOrderKinematicPairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWLowOrderKinematicPairValue
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWLowOrderKinematicPairValue::RWStepKinematics_RWLowOrderKinematicPairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWLowOrderKinematicPairValue::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                              const Standard_Integer theNum,
+                                                              Handle(Interface_Check)& theArch,
+                                                              const Handle(StepKinematics_LowOrderKinematicPairValue)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,8,theArch,"low_order_kinematic_pair_value") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of PairValue
+
+  Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+  theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+  // Own fields of LowOrderKinematicPairValue
+
+  Standard_Real aActualTranslationX;
+  theData->ReadReal (theNum, 3, "actual_translation_x", theArch, aActualTranslationX);
+
+  Standard_Real aActualTranslationY;
+  theData->ReadReal (theNum, 4, "actual_translation_y", theArch, aActualTranslationY);
+
+  Standard_Real aActualTranslationZ;
+  theData->ReadReal (theNum, 5, "actual_translation_z", theArch, aActualTranslationZ);
+
+  Standard_Real aActualRotationX;
+  theData->ReadReal (theNum, 6, "actual_rotation_x", theArch, aActualRotationX);
+
+  Standard_Real aActualRotationY;
+  theData->ReadReal (theNum, 7, "actual_rotation_y", theArch, aActualRotationY);
+
+  Standard_Real aActualRotationZ;
+  theData->ReadReal (theNum, 8, "actual_rotation_z", theArch, aActualRotationZ);
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aPairValue_AppliesToPair,
+            aActualTranslationX,
+            aActualTranslationY,
+            aActualTranslationZ,
+            aActualRotationX,
+            aActualRotationY,
+            aActualRotationZ);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWLowOrderKinematicPairValue::WriteStep (StepData_StepWriter& theSW,
+                                                               const Handle(StepKinematics_LowOrderKinematicPairValue)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Own fields of PairValue
+
+  theSW.Send (theEnt->AppliesToPair());
+
+  // Own fields of LowOrderKinematicPairValue
+
+  theSW.Send (theEnt->ActualTranslationX());
+
+  theSW.Send (theEnt->ActualTranslationY());
+
+  theSW.Send (theEnt->ActualTranslationZ());
+
+  theSW.Send (theEnt->ActualRotationX());
+
+  theSW.Send (theEnt->ActualRotationY());
+
+  theSW.Send (theEnt->ActualRotationZ());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWLowOrderKinematicPairValue::Share (const Handle(StepKinematics_LowOrderKinematicPairValue)& theEnt,
+                                                           Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of PairValue
+
+  iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair());
+
+  // Own fields of LowOrderKinematicPairValue
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_LowOrderKinematicPairValue;
+
+//! Read & Write tool for LowOrderKinematicPairValue
+class RWStepKinematics_RWLowOrderKinematicPairValue
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWLowOrderKinematicPairValue();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_LowOrderKinematicPairValue)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_LowOrderKinematicPairValue)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_LowOrderKinematicPairValue)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWLowOrderKinematicPairValue_HeaderFile_

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 <RWStepKinematics_RWLowOrderKinematicPairWithRange.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_LowOrderKinematicPairWithRange.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWLowOrderKinematicPairWithRange
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWLowOrderKinematicPairWithRange::RWStepKinematics_RWLowOrderKinematicPairWithRange() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWLowOrderKinematicPairWithRange::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                                  const Standard_Integer theNum,
+                                                                  Handle(Interface_Check)& theArch,
+                                                                  const Handle(StepKinematics_LowOrderKinematicPairWithRange)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,24,theArch,"low_order_kinematic_pair_with_range") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of ItemDefinedTransformation
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+  theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+  Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+  if ( theData->IsParamDefined (theNum,3) ) {
+    theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+  }
+  else {
+    hasItemDefinedTransformation_Description = Standard_False;
+    aItemDefinedTransformation_Description.Nullify();
+  }
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+  theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+  theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+  // Inherited fields of KinematicPair
+
+  Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+  theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+  // Inherited fields of LowOrderKinematicPair
+
+  Standard_Boolean aLowOrderKinematicPair_TX;
+  theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX);
+
+  Standard_Boolean aLowOrderKinematicPair_TY;
+  theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY);
+
+  Standard_Boolean aLowOrderKinematicPair_TZ;
+  theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ);
+
+  Standard_Boolean aLowOrderKinematicPair_RX;
+  theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX);
+
+  Standard_Boolean aLowOrderKinematicPair_RY;
+  theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY);
+
+  Standard_Boolean aLowOrderKinematicPair_RZ;
+  theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ);
+
+  // Own fields of LowOrderKinematicPairWithRange
+
+  Standard_Real aLowerLimitActualRotationX;
+  Standard_Boolean hasLowerLimitActualRotationX = Standard_True;
+  if ( theData->IsParamDefined (theNum,13) ) {
+    theData->ReadReal (theNum, 13, "lower_limit_actual_rotation_x", theArch, aLowerLimitActualRotationX);
+  }
+  else {
+    hasLowerLimitActualRotationX = Standard_False;
+    aLowerLimitActualRotationX = 0;
+  }
+
+  Standard_Real aUpperLimitActualRotationX;
+  Standard_Boolean hasUpperLimitActualRotationX = Standard_True;
+  if ( theData->IsParamDefined (theNum,14) ) {
+    theData->ReadReal (theNum, 14, "upper_limit_actual_rotation_x", theArch, aUpperLimitActualRotationX);
+  }
+  else {
+    hasUpperLimitActualRotationX = Standard_False;
+    aUpperLimitActualRotationX = 0;
+  }
+
+  Standard_Real aLowerLimitActualRotationY;
+  Standard_Boolean hasLowerLimitActualRotationY = Standard_True;
+  if ( theData->IsParamDefined (theNum,15) ) {
+    theData->ReadReal (theNum, 15, "lower_limit_actual_rotation_y", theArch, aLowerLimitActualRotationY);
+  }
+  else {
+    hasLowerLimitActualRotationY = Standard_False;
+    aLowerLimitActualRotationY = 0;
+  }
+
+  Standard_Real aUpperLimitActualRotationY;
+  Standard_Boolean hasUpperLimitActualRotationY = Standard_True;
+  if ( theData->IsParamDefined (theNum,16) ) {
+    theData->ReadReal (theNum, 16, "upper_limit_actual_rotation_y", theArch, aUpperLimitActualRotationY);
+  }
+  else {
+    hasUpperLimitActualRotationY = Standard_False;
+    aUpperLimitActualRotationY = 0;
+  }
+
+  Standard_Real aLowerLimitActualRotationZ;
+  Standard_Boolean hasLowerLimitActualRotationZ = Standard_True;
+  if ( theData->IsParamDefined (theNum,17) ) {
+    theData->ReadReal (theNum, 17, "lower_limit_actual_rotation_z", theArch, aLowerLimitActualRotationZ);
+  }
+  else {
+    hasLowerLimitActualRotationZ = Standard_False;
+    aLowerLimitActualRotationZ = 0;
+  }
+
+  Standard_Real aUpperLimitActualRotationZ;
+  Standard_Boolean hasUpperLimitActualRotationZ = Standard_True;
+  if ( theData->IsParamDefined (theNum,18) ) {
+    theData->ReadReal (theNum, 18, "upper_limit_actual_rotation_z", theArch, aUpperLimitActualRotationZ);
+  }
+  else {
+    hasUpperLimitActualRotationZ = Standard_False;
+    aUpperLimitActualRotationZ = 0;
+  }
+
+  Standard_Real aLowerLimitActualTranslationX;
+  Standard_Boolean hasLowerLimitActualTranslationX = Standard_True;
+  if ( theData->IsParamDefined (theNum,19) ) {
+    theData->ReadReal (theNum, 19, "lower_limit_actual_translation_x", theArch, aLowerLimitActualTranslationX);
+  }
+  else {
+    hasLowerLimitActualTranslationX = Standard_False;
+    aLowerLimitActualTranslationX = 0;
+  }
+
+  Standard_Real aUpperLimitActualTranslationX;
+  Standard_Boolean hasUpperLimitActualTranslationX = Standard_True;
+  if ( theData->IsParamDefined (theNum,20) ) {
+    theData->ReadReal (theNum, 20, "upper_limit_actual_translation_x", theArch, aUpperLimitActualTranslationX);
+  }
+  else {
+    hasUpperLimitActualTranslationX = Standard_False;
+    aUpperLimitActualTranslationX = 0;
+  }
+
+  Standard_Real aLowerLimitActualTranslationY;
+  Standard_Boolean hasLowerLimitActualTranslationY = Standard_True;
+  if ( theData->IsParamDefined (theNum,21) ) {
+    theData->ReadReal (theNum, 21, "lower_limit_actual_translation_y", theArch, aLowerLimitActualTranslationY);
+  }
+  else {
+    hasLowerLimitActualTranslationY = Standard_False;
+    aLowerLimitActualTranslationY = 0;
+  }
+
+  Standard_Real aUpperLimitActualTranslationY;
+  Standard_Boolean hasUpperLimitActualTranslationY = Standard_True;
+  if ( theData->IsParamDefined (theNum,22) ) {
+    theData->ReadReal (theNum, 22, "upper_limit_actual_translation_y", theArch, aUpperLimitActualTranslationY);
+  }
+  else {
+    hasUpperLimitActualTranslationY = Standard_False;
+    aUpperLimitActualTranslationY = 0;
+  }
+
+  Standard_Real aLowerLimitActualTranslationZ;
+  Standard_Boolean hasLowerLimitActualTranslationZ = Standard_True;
+  if ( theData->IsParamDefined (theNum,23) ) {
+    theData->ReadReal (theNum, 23, "lower_limit_actual_translation_z", theArch, aLowerLimitActualTranslationZ);
+  }
+  else {
+    hasLowerLimitActualTranslationZ = Standard_False;
+    aLowerLimitActualTranslationZ = 0;
+  }
+
+  Standard_Real aUpperLimitActualTranslationZ;
+  Standard_Boolean hasUpperLimitActualTranslationZ = Standard_True;
+  if ( theData->IsParamDefined (theNum,24) ) {
+    theData->ReadReal (theNum, 24, "upper_limit_actual_translation_z", theArch, aUpperLimitActualTranslationZ);
+  }
+  else {
+    hasUpperLimitActualTranslationZ = Standard_False;
+    aUpperLimitActualTranslationZ = 0;
+  }
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aItemDefinedTransformation_Name,
+            hasItemDefinedTransformation_Description,
+            aItemDefinedTransformation_Description,
+            aItemDefinedTransformation_TransformItem1,
+            aItemDefinedTransformation_TransformItem2,
+            aKinematicPair_Joint,
+            aLowOrderKinematicPair_TX,
+            aLowOrderKinematicPair_TY,
+            aLowOrderKinematicPair_TZ,
+            aLowOrderKinematicPair_RX,
+            aLowOrderKinematicPair_RY,
+            aLowOrderKinematicPair_RZ,
+            hasLowerLimitActualRotationX,
+            aLowerLimitActualRotationX,
+            hasUpperLimitActualRotationX,
+            aUpperLimitActualRotationX,
+            hasLowerLimitActualRotationY,
+            aLowerLimitActualRotationY,
+            hasUpperLimitActualRotationY,
+            aUpperLimitActualRotationY,
+            hasLowerLimitActualRotationZ,
+            aLowerLimitActualRotationZ,
+            hasUpperLimitActualRotationZ,
+            aUpperLimitActualRotationZ,
+            hasLowerLimitActualTranslationX,
+            aLowerLimitActualTranslationX,
+            hasUpperLimitActualTranslationX,
+            aUpperLimitActualTranslationX,
+            hasLowerLimitActualTranslationY,
+            aLowerLimitActualTranslationY,
+            hasUpperLimitActualTranslationY,
+            aUpperLimitActualTranslationY,
+            hasLowerLimitActualTranslationZ,
+            aLowerLimitActualTranslationZ,
+            hasUpperLimitActualTranslationZ,
+            aUpperLimitActualTranslationZ);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWLowOrderKinematicPairWithRange::WriteStep (StepData_StepWriter& theSW,
+                                                                   const Handle(StepKinematics_LowOrderKinematicPairWithRange)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Inherited fields of ItemDefinedTransformation
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+  if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+    theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+  }
+  else theSW.SendUndef();
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Own fields of KinematicPair
+
+  theSW.Send (theEnt->Joint());
+
+  // Own fields of LowOrderKinematicPair
+
+  theSW.SendBoolean (theEnt->TX());
+
+  theSW.SendBoolean (theEnt->TY());
+
+  theSW.SendBoolean (theEnt->TZ());
+
+  theSW.SendBoolean (theEnt->RX());
+
+  theSW.SendBoolean (theEnt->RY());
+
+  theSW.SendBoolean (theEnt->RZ());
+
+  // Own fields of LowOrderKinematicPairWithRange
+
+  if ( theEnt->HasLowerLimitActualRotationX() ) {
+    theSW.Send (theEnt->LowerLimitActualRotationX());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasUpperLimitActualRotationX() ) {
+    theSW.Send (theEnt->UpperLimitActualRotationX());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasLowerLimitActualRotationY() ) {
+    theSW.Send (theEnt->LowerLimitActualRotationY());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasUpperLimitActualRotationY() ) {
+    theSW.Send (theEnt->UpperLimitActualRotationY());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasLowerLimitActualRotationZ() ) {
+    theSW.Send (theEnt->LowerLimitActualRotationZ());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasUpperLimitActualRotationZ() ) {
+    theSW.Send (theEnt->UpperLimitActualRotationZ());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasLowerLimitActualTranslationX() ) {
+    theSW.Send (theEnt->LowerLimitActualTranslationX());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasUpperLimitActualTranslationX() ) {
+    theSW.Send (theEnt->UpperLimitActualTranslationX());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasLowerLimitActualTranslationY() ) {
+    theSW.Send (theEnt->LowerLimitActualTranslationY());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasUpperLimitActualTranslationY() ) {
+    theSW.Send (theEnt->UpperLimitActualTranslationY());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasLowerLimitActualTranslationZ() ) {
+    theSW.Send (theEnt->LowerLimitActualTranslationZ());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasUpperLimitActualTranslationZ() ) {
+    theSW.Send (theEnt->UpperLimitActualTranslationZ());
+  }
+  else theSW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWLowOrderKinematicPairWithRange::Share (const Handle(StepKinematics_LowOrderKinematicPairWithRange)& theEnt,
+                                                               Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of ItemDefinedTransformation
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Inherited fields of KinematicPair
+
+  iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+  // Inherited fields of LowOrderKinematicPair
+
+  // Own fields of LowOrderKinematicPairWithRange
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_LowOrderKinematicPairWithRange;
+
+//! Read & Write tool for LowOrderKinematicPairWithRange
+class RWStepKinematics_RWLowOrderKinematicPairWithRange
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWLowOrderKinematicPairWithRange();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_LowOrderKinematicPairWithRange)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_LowOrderKinematicPairWithRange)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_LowOrderKinematicPairWithRange)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWLowOrderKinematicPairWithRange_HeaderFile_

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 <RWStepKinematics_RWMechanismRepresentation.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_MechanismRepresentation.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_RepresentationContext.hxx>
+#include <StepKinematics_KinematicTopologyRepresentationSelect.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWMechanismRepresentation
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWMechanismRepresentation::RWStepKinematics_RWMechanismRepresentation() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWMechanismRepresentation::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                           const Standard_Integer theNum,
+                                                           Handle(Interface_Check)& theArch,
+                                                           const Handle(StepKinematics_MechanismRepresentation)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,4,theArch,"mechanism_representation") ) return;
+
+  // Inherited fields of Representation
+
+  Handle(TCollection_HAsciiString) aRepresentation_Name;
+  theData->ReadString (theNum, 1, "representation.name", theArch, aRepresentation_Name);
+
+  Handle(StepRepr_HArray1OfRepresentationItem) aRepresentation_Items;
+  Standard_Integer sub2 = 0;
+  if ( theData->ReadSubList (theNum, 2, "representation.items", theArch, sub2) ) {
+    Standard_Integer nb0 = theData->NbParams(sub2);
+    aRepresentation_Items = new StepRepr_HArray1OfRepresentationItem (1, nb0);
+    Standard_Integer num2 = sub2;
+    for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
+      Handle(StepRepr_RepresentationItem) anIt0;
+      theData->ReadEntity (num2, i0, "representation_item", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), anIt0);
+      aRepresentation_Items->SetValue(i0, anIt0);
+    }
+  }
+
+  Handle(StepRepr_RepresentationContext) aRepresentation_ContextOfItems;
+  theData->ReadEntity (theNum, 3, "representation.context_of_items", theArch, STANDARD_TYPE(StepRepr_RepresentationContext), aRepresentation_ContextOfItems);
+
+  // Own fields of MechanismRepresentation
+
+  StepKinematics_KinematicTopologyRepresentationSelect aRepresentedTopology;
+  theData->ReadEntity (theNum, 4, "represented_topology", theArch, aRepresentedTopology);
+
+  // Initialize entity
+  theEnt->Init(aRepresentation_Name,
+            aRepresentation_Items,
+            aRepresentation_ContextOfItems,
+            aRepresentedTopology);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWMechanismRepresentation::WriteStep (StepData_StepWriter& theSW,
+                                                            const Handle(StepKinematics_MechanismRepresentation)& theEnt) const
+{
+
+  // Own fields of Representation
+
+  theSW.Send (theEnt->Name());
+
+  theSW.OpenSub();
+  for (Standard_Integer i1=1; i1 <= theEnt->Items()->Length(); i1++ ) {
+    Handle(StepRepr_RepresentationItem) Var0 = theEnt->Items()->Value(i1);
+    theSW.Send (Var0);
+  }
+  theSW.CloseSub();
+
+  theSW.Send (theEnt->ContextOfItems());
+
+  // Own fields of MechanismRepresentation
+
+  theSW.Send (theEnt->RepresentedTopology().Value());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+
+void RWStepKinematics_RWMechanismRepresentation::Share (const Handle(StepKinematics_MechanismRepresentation)& theEnt,
+                                                        Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of Representation
+
+  for (Standard_Integer i1=1; i1 <= theEnt->StepRepr_Representation::Items()->Length(); i1++ ) {
+    Handle(StepRepr_RepresentationItem) Var0 = theEnt->StepRepr_Representation::Items()->Value(i1);
+    iter.AddItem (Var0);
+  }
+
+  iter.AddItem (theEnt->StepRepr_Representation::ContextOfItems());
+
+  // Own fields of MechanismRepresentation
+
+  iter.AddItem (theEnt->RepresentedTopology().Value());
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_MechanismRepresentation;
+
+//! Read & Write tool for MechanismRepresentation
+class RWStepKinematics_RWMechanismRepresentation
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWMechanismRepresentation();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_MechanismRepresentation)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_MechanismRepresentation)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_MechanismRepresentation)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWMechanismRepresentation_HeaderFile_

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 <RWStepKinematics_RWMechanismStateRepresentation.hxx>
+
+#include <Interface_Check.hxx>
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_RepresentationContext.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_MechanismStateRepresentation.hxx>
+#include <StepKinematics_MechanismRepresentation.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWMechanismStateRepresentation
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWMechanismStateRepresentation::RWStepKinematics_RWMechanismStateRepresentation() {}
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWMechanismStateRepresentation::ReadStep
+  (const Handle(StepData_StepReaderData)& theData,
+   const Standard_Integer theNum,
+   Handle(Interface_Check)& theArch,
+   const Handle(StepKinematics_MechanismStateRepresentation)& theEnt) const
+{
+  // Number of Parameter Control
+  if (!theData->CheckNbParams(theNum, 4, theArch, "mechanism_state_representation")) return;
+
+  // Inherited field : name
+  Handle(TCollection_HAsciiString) aName;
+  theData->ReadString (theNum, 1, "name" ,theArch, aName);
+
+  // Inherited field : items
+  Handle(StepRepr_HArray1OfRepresentationItem) aItems;
+  Handle(StepRepr_RepresentationItem) anEnt;
+  Standard_Integer nsub;
+  if (theData->ReadSubList (theNum, 2, "items", theArch, nsub)) {
+    Standard_Integer nb = theData->NbParams(nsub);
+    aItems = new StepRepr_HArray1OfRepresentationItem (1, nb);
+    for (Standard_Integer i = 1; i <= nb; i ++) {
+      if (theData->ReadEntity (nsub, i, "representation_item", theArch,
+        STANDARD_TYPE(StepRepr_RepresentationItem), anEnt))
+        aItems->SetValue(i, anEnt);
+    }
+  }
+
+  // Inherited field : context_of_items
+  Handle(StepRepr_RepresentationContext) aContextOfItems;
+  theData->ReadEntity(theNum, 3,"context_of_items", theArch, STANDARD_TYPE(StepRepr_RepresentationContext), aContextOfItems);
+
+  // Inherited field : represented_mechanism
+  Handle(StepKinematics_MechanismRepresentation) aRepresentedMechanism;
+  theData->ReadEntity(theNum, 4, "represented_mechanism", theArch, STANDARD_TYPE(StepKinematics_MechanismRepresentation), aRepresentedMechanism);
+
+  // Initialisation of the read entity
+  theEnt->Init(aName, aItems, aContextOfItems, aRepresentedMechanism);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWMechanismStateRepresentation::WriteStep
+  (StepData_StepWriter& theSW,
+   const Handle(StepKinematics_MechanismStateRepresentation)& theEnt) const
+{
+  // Inherited field : name
+  theSW.Send(theEnt->Name());
+
+  // Inherited field : items
+  theSW.OpenSub();
+  for (Standard_Integer i = 1;  i <= theEnt->NbItems();  i++) {
+    theSW.Send(theEnt->ItemsValue(i));
+  }
+  theSW.CloseSub();
+
+  // Inherited field : context_of_items
+  theSW.Send(theEnt->ContextOfItems());
+
+  // Inherited field : represented_mechanism
+  theSW.Send(theEnt->Mechanism());
+
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWMechanismStateRepresentation::Share(const Handle(StepKinematics_MechanismStateRepresentation)& theEnt, Interface_EntityIterator& iter) const
+{
+  Standard_Integer nbElem = theEnt->NbItems();
+  for (Standard_Integer i = 1; i <= nbElem; i++) {
+    iter.GetOneItem(theEnt->ItemsValue(i));
+  }
+  iter.GetOneItem(theEnt->ContextOfItems());
+  iter.GetOneItem(theEnt->Mechanism());
+}
+

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+class StepData_StepReaderData;
+class Interface_Check;
+class StepKinematics_MechanismStateRepresentation;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write Module for MechanismStateRepresentation
+class RWStepKinematics_RWMechanismStateRepresentation
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWMechanismStateRepresentation();
+  
+  Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_MechanismStateRepresentation)& theEnt) const;
+  
+  Standard_EXPORT void WriteStep (StepData_StepWriter& theSW, const Handle(StepKinematics_MechanismStateRepresentation)& theEnt) const;
+  
+  Standard_EXPORT void Share (const Handle(StepKinematics_MechanismStateRepresentation)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWMechanismStateRepresentation_HeaderFile

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 <RWStepKinematics_RWOrientedJoint.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_OrientedJoint.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepShape_Vertex.hxx>
+#include <StepShape_Edge.hxx>
+#include <Standard_Boolean.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWOrientedJoint
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWOrientedJoint::RWStepKinematics_RWOrientedJoint() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWOrientedJoint::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                 const Standard_Integer theNum,
+                                                 Handle(Interface_Check)& theArch,
+                                                 const Handle(StepKinematics_OrientedJoint)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,5,theArch,"oriented_joint") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of Edge
+
+  Handle(StepShape_Vertex) aEdge_EdgeStart;
+  theData->ReadEntity (theNum, 2, "edge.edge_start", theArch, STANDARD_TYPE(StepShape_Vertex), aEdge_EdgeStart);
+
+  Handle(StepShape_Vertex) aEdge_EdgeEnd;
+  theData->ReadEntity (theNum, 3, "edge.edge_end", theArch, STANDARD_TYPE(StepShape_Vertex), aEdge_EdgeEnd);
+
+  // Inherited fields of OrientedEdge
+
+  Handle(StepShape_Edge) aOrientedEdge_EdgeElement;
+  theData->ReadEntity (theNum, 4, "oriented_edge.edge_element", theArch, STANDARD_TYPE(StepShape_Edge), aOrientedEdge_EdgeElement);
+
+  Standard_Boolean aOrientedEdge_Orientation;
+  theData->ReadBoolean (theNum, 5, "oriented_edge.orientation", theArch, aOrientedEdge_Orientation);
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aOrientedEdge_EdgeElement,
+            aOrientedEdge_Orientation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWOrientedJoint::WriteStep (StepData_StepWriter& theSW,
+                                                  const Handle(StepKinematics_OrientedJoint)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Own fields of Edge
+
+  theSW.Send (theEnt->EdgeStart());
+
+  theSW.Send (theEnt->EdgeEnd());
+
+  // Own fields of OrientedEdge
+
+  theSW.Send (theEnt->EdgeElement());
+
+  theSW.SendBoolean (theEnt->Orientation());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWOrientedJoint::Share (const Handle(StepKinematics_OrientedJoint)& theEnt,
+                                              Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of Edge
+
+  iter.AddItem (theEnt->StepShape_Edge::EdgeStart());
+
+  iter.AddItem (theEnt->StepShape_Edge::EdgeEnd());
+
+  // Inherited fields of OrientedEdge
+
+  iter.AddItem (theEnt->StepShape_OrientedEdge::EdgeElement());
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_OrientedJoint;
+
+//! Read & Write tool for OrientedJoint
+class RWStepKinematics_RWOrientedJoint
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWOrientedJoint();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_OrientedJoint)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_OrientedJoint)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_OrientedJoint)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWOrientedJoint_HeaderFile_

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 <RWStepKinematics_RWPairRepresentationRelationship.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PairRepresentationRelationship.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_Representation.hxx>
+#include <StepRepr_RepresentationRelationshipWithTransformation.hxx>
+#include <StepRepr_RepresentationOrRepresentationReference.hxx>
+#include <StepRepr_Transformation.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPairRepresentationRelationship
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWPairRepresentationRelationship::RWStepKinematics_RWPairRepresentationRelationship() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPairRepresentationRelationship::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                                  const Standard_Integer theNum,
+                                                                  Handle(Interface_Check)& theArch,
+                                                                  const Handle(StepKinematics_PairRepresentationRelationship)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,6,theArch,"pair_representation_relationship") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of RepresentationRelationship
+
+  Handle(TCollection_HAsciiString) aRepresentationRelationship_Name;
+  theData->ReadString (theNum, 2, "representation_relationship.name", theArch, aRepresentationRelationship_Name);
+
+  Handle(TCollection_HAsciiString) aRepresentationRelationship_Description;
+  Standard_Boolean hasRepresentationRelationship_Description = Standard_True;
+  if ( theData->IsParamDefined (theNum,3) ) {
+    theData->ReadString (theNum, 3, "representation_relationship.description", theArch, aRepresentationRelationship_Description);
+  }
+  else {
+    hasRepresentationRelationship_Description = Standard_False;
+    aRepresentationRelationship_Description.Nullify();
+  }
+
+  StepRepr_RepresentationOrRepresentationReference aRepresentationRelationship_Rep1;
+  theData->ReadEntity (theNum, 4, "representation_relationship.rep1", theArch, aRepresentationRelationship_Rep1);
+
+  StepRepr_RepresentationOrRepresentationReference aRepresentationRelationship_Rep2;
+  theData->ReadEntity (theNum, 5, "representation_relationship.rep2", theArch, aRepresentationRelationship_Rep2);
+
+  // Inherited fields of RepresentationRelationshipWithTransformation
+
+  StepRepr_Transformation aRepresentationRelationshipWithTransformation_TransformationOperator;
+  theData->ReadEntity (theNum, 6, "representation_relationship_with_transformation.transformation_operator", theArch, aRepresentationRelationshipWithTransformation_TransformationOperator);
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aRepresentationRelationship_Name,
+            hasRepresentationRelationship_Description,
+            aRepresentationRelationship_Description,
+            aRepresentationRelationship_Rep1,
+            aRepresentationRelationship_Rep2,
+            aRepresentationRelationshipWithTransformation_TransformationOperator);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPairRepresentationRelationship::WriteStep (StepData_StepWriter& theSW,
+                                                                   const Handle(StepKinematics_PairRepresentationRelationship)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Own fields of RepresentationRelationship
+
+  theSW.Send (theEnt->Name());
+
+
+  if (theEnt->RepresentationRelationshipWithTransformation()->HasDescription())
+    theSW.Send (theEnt->RepresentationRelationshipWithTransformation()->Description());
+  else theSW.SendUndef();
+
+  theSW.Send (theEnt->RepresentationRelationshipWithTransformation()->Rep1());
+
+  theSW.Send (theEnt->RepresentationRelationshipWithTransformation()->Rep2());
+
+  // Inherited fields of RepresentationRelationshipWithTransformation
+
+  theSW.Send (theEnt->RepresentationRelationshipWithTransformation()->TransformationOperator().Value());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPairRepresentationRelationship::Share (const Handle(StepKinematics_PairRepresentationRelationship)& theEnt,
+                                                               Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of RepresentationRelationship
+
+  iter.AddItem (theEnt->RepresentationRelationshipWithTransformation()->Rep1());
+
+  iter.AddItem (theEnt->RepresentationRelationshipWithTransformation()->Rep2());
+
+  // Inherited fields of RepresentationRelationshipWithTransformation
+
+  iter.AddItem (theEnt->RepresentationRelationshipWithTransformation()->TransformationOperator().Value());
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PairRepresentationRelationship;
+
+//! Read & Write tool for PairRepresentationRelationship
+class RWStepKinematics_RWPairRepresentationRelationship
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWPairRepresentationRelationship();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PairRepresentationRelationship)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PairRepresentationRelationship)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_PairRepresentationRelationship)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPairRepresentationRelationship_HeaderFile_

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 <RWStepKinematics_RWPlanarCurvePair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PlanarCurvePair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Curve.hxx>
+#include <Standard_Boolean.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPlanarCurvePair
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWPlanarCurvePair::RWStepKinematics_RWPlanarCurvePair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPlanarCurvePair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                   const Standard_Integer theNum,
+                                                   Handle(Interface_Check)& theArch,
+                                                   const Handle(StepKinematics_PlanarCurvePair)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,9,theArch,"planar_curve_pair") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of ItemDefinedTransformation
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+  theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+  Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+  if ( theData->IsParamDefined (theNum,3) ) {
+    theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+  }
+  else {
+    hasItemDefinedTransformation_Description = Standard_False;
+    aItemDefinedTransformation_Description.Nullify();
+  }
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+  theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+  theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+  // Inherited fields of KinematicPair
+
+  Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+  theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+  // Own fields of PlanarCurvePair
+
+  Handle(StepGeom_Curve) aCurve1;
+  theData->ReadEntity (theNum, 7, "curve1", theArch, STANDARD_TYPE(StepGeom_Curve), aCurve1);
+
+  Handle(StepGeom_Curve) aCurve2;
+  theData->ReadEntity (theNum, 8, "curve2", theArch, STANDARD_TYPE(StepGeom_Curve), aCurve2);
+
+  Standard_Boolean aOrientation;
+  theData->ReadBoolean (theNum, 9, "orientation", theArch, aOrientation);
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aItemDefinedTransformation_Name,
+            hasItemDefinedTransformation_Description,
+            aItemDefinedTransformation_Description,
+            aItemDefinedTransformation_TransformItem1,
+            aItemDefinedTransformation_TransformItem2,
+            aKinematicPair_Joint,
+            aCurve1,
+            aCurve2,
+            aOrientation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPlanarCurvePair::WriteStep (StepData_StepWriter& theSW,
+                                                    const Handle(StepKinematics_PlanarCurvePair)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Inherited fields of ItemDefinedTransformation
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+  if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+    theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+  }
+  else theSW.SendUndef();
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Own fields of KinematicPair
+
+  theSW.Send (theEnt->Joint());
+
+  // Own fields of PlanarCurvePair
+
+  theSW.Send (theEnt->Curve1());
+
+  theSW.Send (theEnt->Curve2());
+
+  theSW.SendBoolean (theEnt->Orientation());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPlanarCurvePair::Share (const Handle(StepKinematics_PlanarCurvePair)& theEnt,
+                                                Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of ItemDefinedTransformation
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Inherited fields of KinematicPair
+
+  iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+  // Own fields of PlanarCurvePair
+
+  iter.AddItem (theEnt->Curve1());
+
+  iter.AddItem (theEnt->Curve2());
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PlanarCurvePair;
+
+//! Read & Write tool for PlanarCurvePair
+class RWStepKinematics_RWPlanarCurvePair
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWPlanarCurvePair();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PlanarCurvePair)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PlanarCurvePair)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_PlanarCurvePair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPlanarCurvePair_HeaderFile_

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 <RWStepKinematics_RWPlanarCurvePairRange.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PlanarCurvePairRange.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Curve.hxx>
+#include <Standard_Boolean.hxx>
+#include <StepGeom_TrimmedCurve.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPlanarCurvePairRange
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWPlanarCurvePairRange::RWStepKinematics_RWPlanarCurvePairRange() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPlanarCurvePairRange::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                        const Standard_Integer theNum,
+                                                        Handle(Interface_Check)& theArch,
+                                                        const Handle(StepKinematics_PlanarCurvePairRange)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,11,theArch,"planar_curve_pair_range") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of ItemDefinedTransformation
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+  theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+  Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+  if ( theData->IsParamDefined (theNum,3) ) {
+    theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+  }
+  else {
+    hasItemDefinedTransformation_Description = Standard_False;
+    aItemDefinedTransformation_Description.Nullify();
+  }
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+  theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+  theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+  // Inherited fields of KinematicPair
+
+  Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+  theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+  // Inherited fields of PlanarCurvePair
+
+  Handle(StepGeom_Curve) aPlanarCurvePair_Curve1;
+  theData->ReadEntity (theNum, 7, "planar_curve_pair.curve1", theArch, STANDARD_TYPE(StepGeom_Curve), aPlanarCurvePair_Curve1);
+
+  Handle(StepGeom_Curve) aPlanarCurvePair_Curve2;
+  theData->ReadEntity (theNum, 8, "planar_curve_pair.curve2", theArch, STANDARD_TYPE(StepGeom_Curve), aPlanarCurvePair_Curve2);
+
+  Standard_Boolean aPlanarCurvePair_Orientation;
+  theData->ReadBoolean (theNum, 9, "planar_curve_pair.orientation", theArch, aPlanarCurvePair_Orientation);
+
+  // Own fields of PlanarCurvePairRange
+
+  Handle(StepGeom_TrimmedCurve) aRangeOnCurve1;
+  theData->ReadEntity (theNum, 10, "range_on_curve1", theArch, STANDARD_TYPE(StepGeom_TrimmedCurve), aRangeOnCurve1);
+
+  Handle(StepGeom_TrimmedCurve) aRangeOnCurve2;
+  theData->ReadEntity (theNum, 11, "range_on_curve2", theArch, STANDARD_TYPE(StepGeom_TrimmedCurve), aRangeOnCurve2);
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aItemDefinedTransformation_Name,
+            hasItemDefinedTransformation_Description,
+            aItemDefinedTransformation_Description,
+            aItemDefinedTransformation_TransformItem1,
+            aItemDefinedTransformation_TransformItem2,
+            aKinematicPair_Joint,
+            aPlanarCurvePair_Curve1,
+            aPlanarCurvePair_Curve2,
+            aPlanarCurvePair_Orientation,
+            aRangeOnCurve1,
+            aRangeOnCurve2);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPlanarCurvePairRange::WriteStep (StepData_StepWriter& theSW,
+                                                         const Handle(StepKinematics_PlanarCurvePairRange)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Inherited fields of ItemDefinedTransformation
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+  if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+    theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+  }
+  else theSW.SendUndef();
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Own fields of KinematicPair
+
+  theSW.Send (theEnt->Joint());
+
+  // Own fields of PlanarCurvePair
+
+  theSW.Send (theEnt->Curve1());
+
+  theSW.Send (theEnt->Curve2());
+
+  theSW.SendBoolean (theEnt->Orientation());
+
+  // Own fields of PlanarCurvePairRange
+
+  theSW.Send (theEnt->RangeOnCurve1());
+
+  theSW.Send (theEnt->RangeOnCurve2());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPlanarCurvePairRange::Share (const Handle(StepKinematics_PlanarCurvePairRange)& theEnt,
+                                                     Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of ItemDefinedTransformation
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Inherited fields of KinematicPair
+
+  iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+  // Inherited fields of PlanarCurvePair
+
+  iter.AddItem (theEnt->StepKinematics_PlanarCurvePair::Curve1());
+
+  iter.AddItem (theEnt->StepKinematics_PlanarCurvePair::Curve2());
+
+  // Own fields of PlanarCurvePairRange
+
+  iter.AddItem (theEnt->RangeOnCurve1());
+
+  iter.AddItem (theEnt->RangeOnCurve2());
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PlanarCurvePairRange;
+
+//! Read & Write tool for PlanarCurvePairRange
+class RWStepKinematics_RWPlanarCurvePairRange
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWPlanarCurvePairRange();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PlanarCurvePairRange)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PlanarCurvePairRange)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_PlanarCurvePairRange)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPlanarCurvePairRange_HeaderFile_

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 <RWStepKinematics_RWPlanarPair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PlanarPair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPlanarPair
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWPlanarPair::RWStepKinematics_RWPlanarPair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPlanarPair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                              const Standard_Integer theNum,
+                                              Handle(Interface_Check)& theArch,
+                                              const Handle(StepKinematics_PlanarPair)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,12,theArch,"planar_pair") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of ItemDefinedTransformation
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+  theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+  Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+  if ( theData->IsParamDefined (theNum,3) ) {
+    theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+  }
+  else {
+    hasItemDefinedTransformation_Description = Standard_False;
+    aItemDefinedTransformation_Description.Nullify();
+  }
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+  theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+  theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+  // Inherited fields of KinematicPair
+
+  Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+  theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+  // Inherited fields of LowOrderKinematicPair
+
+  Standard_Boolean aLowOrderKinematicPair_TX;
+  theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX);
+
+  Standard_Boolean aLowOrderKinematicPair_TY;
+  theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY);
+
+  Standard_Boolean aLowOrderKinematicPair_TZ;
+  theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ);
+
+  Standard_Boolean aLowOrderKinematicPair_RX;
+  theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX);
+
+  Standard_Boolean aLowOrderKinematicPair_RY;
+  theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY);
+
+  Standard_Boolean aLowOrderKinematicPair_RZ;
+  theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ);
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aItemDefinedTransformation_Name,
+            hasItemDefinedTransformation_Description,
+            aItemDefinedTransformation_Description,
+            aItemDefinedTransformation_TransformItem1,
+            aItemDefinedTransformation_TransformItem2,
+            aKinematicPair_Joint,
+            aLowOrderKinematicPair_TX,
+            aLowOrderKinematicPair_TY,
+            aLowOrderKinematicPair_TZ,
+            aLowOrderKinematicPair_RX,
+            aLowOrderKinematicPair_RY,
+            aLowOrderKinematicPair_RZ);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPlanarPair::WriteStep (StepData_StepWriter& theSW,
+                                               const Handle(StepKinematics_PlanarPair)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Inherited fields of ItemDefinedTransformation
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+  if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+    theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+  }
+  else theSW.SendUndef();
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Own fields of KinematicPair
+
+  theSW.Send (theEnt->Joint());
+
+  // Own fields of LowOrderKinematicPair
+
+  theSW.SendBoolean (theEnt->TX());
+
+  theSW.SendBoolean (theEnt->TY());
+
+  theSW.SendBoolean (theEnt->TZ());
+
+  theSW.SendBoolean (theEnt->RX());
+
+  theSW.SendBoolean (theEnt->RY());
+
+  theSW.SendBoolean (theEnt->RZ());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPlanarPair::Share (const Handle(StepKinematics_PlanarPair)& theEnt,
+                                           Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of ItemDefinedTransformation
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Inherited fields of KinematicPair
+
+  iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+  // Inherited fields of LowOrderKinematicPair
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PlanarPair;
+
+//! Read & Write tool for PlanarPair
+class RWStepKinematics_RWPlanarPair
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWPlanarPair();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PlanarPair)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PlanarPair)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_PlanarPair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPlanarPair_HeaderFile_

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 <RWStepKinematics_RWPlanarPairValue.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PlanarPairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPlanarPairValue
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWPlanarPairValue::RWStepKinematics_RWPlanarPairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPlanarPairValue::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                   const Standard_Integer theNum,
+                                                   Handle(Interface_Check)& theArch,
+                                                   const Handle(StepKinematics_PlanarPairValue)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,5,theArch,"planar_pair_value") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of PairValue
+
+  Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+  theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+  // Own fields of PlanarPairValue
+
+  Standard_Real aActualRotation;
+  theData->ReadReal (theNum, 3, "actual_rotation", theArch, aActualRotation);
+
+  Standard_Real aActualTranslationX;
+  theData->ReadReal (theNum, 4, "actual_translation_x", theArch, aActualTranslationX);
+
+  Standard_Real aActualTranslationY;
+  theData->ReadReal (theNum, 5, "actual_translation_y", theArch, aActualTranslationY);
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aPairValue_AppliesToPair,
+            aActualRotation,
+            aActualTranslationX,
+            aActualTranslationY);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPlanarPairValue::WriteStep (StepData_StepWriter& theSW,
+                                                    const Handle(StepKinematics_PlanarPairValue)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Own fields of PairValue
+
+  theSW.Send (theEnt->AppliesToPair());
+
+  // Own fields of PlanarPairValue
+
+  theSW.Send (theEnt->ActualRotation());
+
+  theSW.Send (theEnt->ActualTranslationX());
+
+  theSW.Send (theEnt->ActualTranslationY());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPlanarPairValue::Share (const Handle(StepKinematics_PlanarPairValue)& theEnt,
+                                                Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of PairValue
+
+  iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair());
+
+  // Own fields of PlanarPairValue
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PlanarPairValue;
+
+//! Read & Write tool for PlanarPairValue
+class RWStepKinematics_RWPlanarPairValue
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWPlanarPairValue();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PlanarPairValue)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PlanarPairValue)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_PlanarPairValue)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPlanarPairValue_HeaderFile_

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 <RWStepKinematics_RWPlanarPairWithRange.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PlanarPairWithRange.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPlanarPairWithRange
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWPlanarPairWithRange::RWStepKinematics_RWPlanarPairWithRange() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPlanarPairWithRange::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                       const Standard_Integer theNum,
+                                                       Handle(Interface_Check)& theArch,
+                                                       const Handle(StepKinematics_PlanarPairWithRange)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,18,theArch,"planar_pair_with_range") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of ItemDefinedTransformation
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+  theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+  Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+  if ( theData->IsParamDefined (theNum,3) ) {
+    theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+  }
+  else {
+    hasItemDefinedTransformation_Description = Standard_False;
+    aItemDefinedTransformation_Description.Nullify();
+  }
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+  theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+  theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+  // Inherited fields of KinematicPair
+
+  Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+  theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+  // Inherited fields of LowOrderKinematicPair
+
+  Standard_Boolean aLowOrderKinematicPair_TX;
+  theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX);
+
+  Standard_Boolean aLowOrderKinematicPair_TY;
+  theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY);
+
+  Standard_Boolean aLowOrderKinematicPair_TZ;
+  theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ);
+
+  Standard_Boolean aLowOrderKinematicPair_RX;
+  theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX);
+
+  Standard_Boolean aLowOrderKinematicPair_RY;
+  theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY);
+
+  Standard_Boolean aLowOrderKinematicPair_RZ;
+  theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ);
+
+  // Own fields of PlanarPairWithRange
+
+  Standard_Real aLowerLimitActualRotation;
+  Standard_Boolean hasLowerLimitActualRotation = Standard_True;
+  if ( theData->IsParamDefined (theNum,13) ) {
+    theData->ReadReal (theNum, 13, "lower_limit_actual_rotation", theArch, aLowerLimitActualRotation);
+  }
+  else {
+    hasLowerLimitActualRotation = Standard_False;
+    aLowerLimitActualRotation = 0;
+  }
+
+  Standard_Real aUpperLimitActualRotation;
+  Standard_Boolean hasUpperLimitActualRotation = Standard_True;
+  if ( theData->IsParamDefined (theNum,14) ) {
+    theData->ReadReal (theNum, 14, "upper_limit_actual_rotation", theArch, aUpperLimitActualRotation);
+  }
+  else {
+    hasUpperLimitActualRotation = Standard_False;
+    aUpperLimitActualRotation = 0;
+  }
+
+  Standard_Real aLowerLimitActualTranslationX;
+  Standard_Boolean hasLowerLimitActualTranslationX = Standard_True;
+  if ( theData->IsParamDefined (theNum,15) ) {
+    theData->ReadReal (theNum, 15, "lower_limit_actual_translation_x", theArch, aLowerLimitActualTranslationX);
+  }
+  else {
+    hasLowerLimitActualTranslationX = Standard_False;
+    aLowerLimitActualTranslationX = 0;
+  }
+
+  Standard_Real aUpperLimitActualTranslationX;
+  Standard_Boolean hasUpperLimitActualTranslationX = Standard_True;
+  if ( theData->IsParamDefined (theNum,16) ) {
+    theData->ReadReal (theNum, 16, "upper_limit_actual_translation_x", theArch, aUpperLimitActualTranslationX);
+  }
+  else {
+    hasUpperLimitActualTranslationX = Standard_False;
+    aUpperLimitActualTranslationX = 0;
+  }
+
+  Standard_Real aLowerLimitActualTranslationY;
+  Standard_Boolean hasLowerLimitActualTranslationY = Standard_True;
+  if ( theData->IsParamDefined (theNum,17) ) {
+    theData->ReadReal (theNum, 17, "lower_limit_actual_translation_y", theArch, aLowerLimitActualTranslationY);
+  }
+  else {
+    hasLowerLimitActualTranslationY = Standard_False;
+    aLowerLimitActualTranslationY = 0;
+  }
+
+  Standard_Real aUpperLimitActualTranslationY;
+  Standard_Boolean hasUpperLimitActualTranslationY = Standard_True;
+  if ( theData->IsParamDefined (theNum,18) ) {
+    theData->ReadReal (theNum, 18, "upper_limit_actual_translation_y", theArch, aUpperLimitActualTranslationY);
+  }
+  else {
+    hasUpperLimitActualTranslationY = Standard_False;
+    aUpperLimitActualTranslationY = 0;
+  }
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aItemDefinedTransformation_Name,
+            hasItemDefinedTransformation_Description,
+            aItemDefinedTransformation_Description,
+            aItemDefinedTransformation_TransformItem1,
+            aItemDefinedTransformation_TransformItem2,
+            aKinematicPair_Joint,
+            aLowOrderKinematicPair_TX,
+            aLowOrderKinematicPair_TY,
+            aLowOrderKinematicPair_TZ,
+            aLowOrderKinematicPair_RX,
+            aLowOrderKinematicPair_RY,
+            aLowOrderKinematicPair_RZ,
+            hasLowerLimitActualRotation,
+            aLowerLimitActualRotation,
+            hasUpperLimitActualRotation,
+            aUpperLimitActualRotation,
+            hasLowerLimitActualTranslationX,
+            aLowerLimitActualTranslationX,
+            hasUpperLimitActualTranslationX,
+            aUpperLimitActualTranslationX,
+            hasLowerLimitActualTranslationY,
+            aLowerLimitActualTranslationY,
+            hasUpperLimitActualTranslationY,
+            aUpperLimitActualTranslationY);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPlanarPairWithRange::WriteStep (StepData_StepWriter& theSW,
+                                                        const Handle(StepKinematics_PlanarPairWithRange)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Inherited fields of ItemDefinedTransformation
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+  if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+    theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+  }
+  else theSW.SendUndef();
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Own fields of KinematicPair
+
+  theSW.Send (theEnt->Joint());
+
+  // Own fields of LowOrderKinematicPair
+
+  theSW.SendBoolean (theEnt->TX());
+
+  theSW.SendBoolean (theEnt->TY());
+
+  theSW.SendBoolean (theEnt->TZ());
+
+  theSW.SendBoolean (theEnt->RX());
+
+  theSW.SendBoolean (theEnt->RY());
+
+  theSW.SendBoolean (theEnt->RZ());
+
+  // Own fields of PlanarPairWithRange
+
+  if ( theEnt->HasLowerLimitActualRotation() ) {
+    theSW.Send (theEnt->LowerLimitActualRotation());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasUpperLimitActualRotation() ) {
+    theSW.Send (theEnt->UpperLimitActualRotation());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasLowerLimitActualTranslationX() ) {
+    theSW.Send (theEnt->LowerLimitActualTranslationX());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasUpperLimitActualTranslationX() ) {
+    theSW.Send (theEnt->UpperLimitActualTranslationX());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasLowerLimitActualTranslationY() ) {
+    theSW.Send (theEnt->LowerLimitActualTranslationY());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasUpperLimitActualTranslationY() ) {
+    theSW.Send (theEnt->UpperLimitActualTranslationY());
+  }
+  else theSW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPlanarPairWithRange::Share (const Handle(StepKinematics_PlanarPairWithRange)& theEnt,
+                                                    Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of ItemDefinedTransformation
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Inherited fields of KinematicPair
+
+  iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+  // Inherited fields of LowOrderKinematicPair
+
+  // Own fields of PlanarPairWithRange
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PlanarPairWithRange;
+
+//! Read & Write tool for PlanarPairWithRange
+class RWStepKinematics_RWPlanarPairWithRange
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWPlanarPairWithRange();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PlanarPairWithRange)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PlanarPairWithRange)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_PlanarPairWithRange)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPlanarPairWithRange_HeaderFile_

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 <RWStepKinematics_RWPointOnPlanarCurvePair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PointOnPlanarCurvePair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Curve.hxx>
+#include <Standard_Boolean.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPointOnPlanarCurvePair
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWPointOnPlanarCurvePair::RWStepKinematics_RWPointOnPlanarCurvePair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPointOnPlanarCurvePair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                          const Standard_Integer theNum,
+                                                          Handle(Interface_Check)& theArch,
+                                                          const Handle(StepKinematics_PointOnPlanarCurvePair)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,8,theArch,"point_on_planar_curve_pair") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of ItemDefinedTransformation
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+  theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+  Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+  if ( theData->IsParamDefined (theNum,3) ) {
+    theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+  }
+  else {
+    hasItemDefinedTransformation_Description = Standard_False;
+    aItemDefinedTransformation_Description.Nullify();
+  }
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+  theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+  theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+  // Inherited fields of KinematicPair
+
+  Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+  theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+  // Own fields of PointOnPlanarCurvePair
+
+  Handle(StepGeom_Curve) aPairCurve;
+  theData->ReadEntity (theNum, 7, "pair_curve", theArch, STANDARD_TYPE(StepGeom_Curve), aPairCurve);
+
+  Standard_Boolean aOrientation;
+  theData->ReadBoolean (theNum, 8, "orientation", theArch, aOrientation);
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aItemDefinedTransformation_Name,
+            hasItemDefinedTransformation_Description,
+            aItemDefinedTransformation_Description,
+            aItemDefinedTransformation_TransformItem1,
+            aItemDefinedTransformation_TransformItem2,
+            aKinematicPair_Joint,
+            aPairCurve,
+            aOrientation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPointOnPlanarCurvePair::WriteStep (StepData_StepWriter& theSW,
+                                                           const Handle(StepKinematics_PointOnPlanarCurvePair)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Inherited fields of ItemDefinedTransformation
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+  if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+    theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+  }
+  else theSW.SendUndef();
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Own fields of KinematicPair
+
+  theSW.Send (theEnt->Joint());
+
+  // Own fields of PointOnPlanarCurvePair
+
+  theSW.Send (theEnt->PairCurve());
+
+  theSW.SendBoolean (theEnt->Orientation());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPointOnPlanarCurvePair::Share (const Handle(StepKinematics_PointOnPlanarCurvePair)& theEnt,
+                                                       Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of ItemDefinedTransformation
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Inherited fields of KinematicPair
+
+  iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+  // Own fields of PointOnPlanarCurvePair
+
+  iter.AddItem (theEnt->PairCurve());
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PointOnPlanarCurvePair;
+
+//! Read & Write tool for PointOnPlanarCurvePair
+class RWStepKinematics_RWPointOnPlanarCurvePair
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWPointOnPlanarCurvePair();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PointOnPlanarCurvePair)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PointOnPlanarCurvePair)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_PointOnPlanarCurvePair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPointOnPlanarCurvePair_HeaderFile_

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 <RWStepKinematics_RWPointOnPlanarCurvePairValue.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PointOnPlanarCurvePairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <StepGeom_PointOnCurve.hxx>
+#include <StepKinematics_SpatialRotation.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPointOnPlanarCurvePairValue
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWPointOnPlanarCurvePairValue::RWStepKinematics_RWPointOnPlanarCurvePairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPointOnPlanarCurvePairValue::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                               const Standard_Integer theNum,
+                                                               Handle(Interface_Check)& theArch,
+                                                               const Handle(StepKinematics_PointOnPlanarCurvePairValue)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,4,theArch,"point_on_planar_curve_pair_value") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of PairValue
+
+  Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+  theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+  // Own fields of PointOnPlanarCurvePairValue
+
+  Handle(StepGeom_PointOnCurve) aActualPointOnCurve;
+  theData->ReadEntity (theNum, 3, "actual_point_on_curve", theArch, STANDARD_TYPE(StepGeom_PointOnCurve), aActualPointOnCurve);
+
+  StepKinematics_SpatialRotation aInputOrientation;
+  if (theData->SubListNumber(theNum, 4, Standard_True))
+  {
+    Handle(TColStd_HArray1OfReal) aItems;
+    Standard_Integer nsub = 0;
+    if (theData->ReadSubList(theNum, 4, "items", theArch, nsub)) {
+      Standard_Integer nb = theData->NbParams(nsub);
+      aItems = new TColStd_HArray1OfReal(1, nb);
+      Standard_Integer num2 = nsub;
+      for (Standard_Integer i0 = 1; i0 <= nb; i0++) {
+        Standard_Real anIt0;
+        theData->ReadReal(num2, i0, "real", theArch, anIt0);
+        aItems->SetValue(i0, anIt0);
+      }
+    }
+    aInputOrientation.SetValue(aItems);
+  }
+  else
+    theData->ReadEntity(theNum, 4, "input_orientation", theArch, aInputOrientation);
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aPairValue_AppliesToPair,
+            aActualPointOnCurve,
+            aInputOrientation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPointOnPlanarCurvePairValue::WriteStep (StepData_StepWriter& theSW,
+                                                                const Handle(StepKinematics_PointOnPlanarCurvePairValue)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Own fields of PairValue
+
+  theSW.Send (theEnt->AppliesToPair());
+
+  // Own fields of PointOnPlanarCurvePairValue
+
+  theSW.Send (theEnt->ActualPointOnCurve());
+
+  if (!theEnt->InputOrientation().YprRotation().IsNull())
+  {
+    // Inherited field : YPR
+    theSW.OpenSub();
+    for (Standard_Integer i = 1; i <= theEnt->InputOrientation().YprRotation()->Length(); i++) {
+      theSW.Send(theEnt->InputOrientation().YprRotation()->Value(i));
+    }
+    theSW.CloseSub();
+  }
+  else
+    theSW.Send(theEnt->InputOrientation().Value());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPointOnPlanarCurvePairValue::Share (const Handle(StepKinematics_PointOnPlanarCurvePairValue)& theEnt,
+                                                            Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of PairValue
+
+  iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair());
+
+  // Own fields of PointOnPlanarCurvePairValue
+
+  iter.AddItem (theEnt->ActualPointOnCurve());
+
+  if (!theEnt->InputOrientation().RotationAboutDirection().IsNull())
+    iter.AddItem(theEnt->InputOrientation().Value());
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PointOnPlanarCurvePairValue;
+
+//! Read & Write tool for PointOnPlanarCurvePairValue
+class RWStepKinematics_RWPointOnPlanarCurvePairValue
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWPointOnPlanarCurvePairValue();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PointOnPlanarCurvePairValue)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PointOnPlanarCurvePairValue)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_PointOnPlanarCurvePairValue)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPointOnPlanarCurvePairValue_HeaderFile_

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 <RWStepKinematics_RWPointOnPlanarCurvePairWithRange.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PointOnPlanarCurvePairWithRange.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Curve.hxx>
+#include <Standard_Boolean.hxx>
+#include <StepGeom_TrimmedCurve.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPointOnPlanarCurvePairWithRange
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWPointOnPlanarCurvePairWithRange::RWStepKinematics_RWPointOnPlanarCurvePairWithRange() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPointOnPlanarCurvePairWithRange::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                                   const Standard_Integer theNum,
+                                                                   Handle(Interface_Check)& theArch,
+                                                                   const Handle(StepKinematics_PointOnPlanarCurvePairWithRange)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,15,theArch,"point_on_planar_curve_pair_with_range") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of ItemDefinedTransformation
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+  theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+  Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+  if ( theData->IsParamDefined (theNum,3) ) {
+    theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+  }
+  else {
+    hasItemDefinedTransformation_Description = Standard_False;
+    aItemDefinedTransformation_Description.Nullify();
+  }
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+  theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+  theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+  // Inherited fields of KinematicPair
+
+  Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+  theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+  // Inherited fields of PointOnPlanarCurvePair
+
+  Handle(StepGeom_Curve) aPointOnPlanarCurvePair_PairCurve;
+  theData->ReadEntity (theNum, 7, "point_on_planar_curve_pair.pair_curve", theArch, STANDARD_TYPE(StepGeom_Curve), aPointOnPlanarCurvePair_PairCurve);
+
+  Standard_Boolean aPointOnPlanarCurvePair_Orientation;
+  theData->ReadBoolean (theNum, 8, "point_on_planar_curve_pair.orientation", theArch, aPointOnPlanarCurvePair_Orientation);
+
+  // Own fields of PointOnPlanarCurvePairWithRange
+
+  Handle(StepGeom_TrimmedCurve) aRangeOnPairCurve;
+  theData->ReadEntity (theNum, 9, "range_on_pair_curve", theArch, STANDARD_TYPE(StepGeom_TrimmedCurve), aRangeOnPairCurve);
+
+  Standard_Real aLowerLimitYaw;
+  Standard_Boolean hasLowerLimitYaw = Standard_True;
+  if ( theData->IsParamDefined (theNum,10) ) {
+    theData->ReadReal (theNum, 10, "lower_limit_yaw", theArch, aLowerLimitYaw);
+  }
+  else {
+    hasLowerLimitYaw = Standard_False;
+    aLowerLimitYaw = 0;
+  }
+
+  Standard_Real aUpperLimitYaw;
+  Standard_Boolean hasUpperLimitYaw = Standard_True;
+  if ( theData->IsParamDefined (theNum,11) ) {
+    theData->ReadReal (theNum, 11, "upper_limit_yaw", theArch, aUpperLimitYaw);
+  }
+  else {
+    hasUpperLimitYaw = Standard_False;
+    aUpperLimitYaw = 0;
+  }
+
+  Standard_Real aLowerLimitPitch;
+  Standard_Boolean hasLowerLimitPitch = Standard_True;
+  if ( theData->IsParamDefined (theNum,12) ) {
+    theData->ReadReal (theNum, 12, "lower_limit_pitch", theArch, aLowerLimitPitch);
+  }
+  else {
+    hasLowerLimitPitch = Standard_False;
+    aLowerLimitPitch = 0;
+  }
+
+  Standard_Real aUpperLimitPitch;
+  Standard_Boolean hasUpperLimitPitch = Standard_True;
+  if ( theData->IsParamDefined (theNum,13) ) {
+    theData->ReadReal (theNum, 13, "upper_limit_pitch", theArch, aUpperLimitPitch);
+  }
+  else {
+    hasUpperLimitPitch = Standard_False;
+    aUpperLimitPitch = 0;
+  }
+
+  Standard_Real aLowerLimitRoll;
+  Standard_Boolean hasLowerLimitRoll = Standard_True;
+  if ( theData->IsParamDefined (theNum,14) ) {
+    theData->ReadReal (theNum, 14, "lower_limit_roll", theArch, aLowerLimitRoll);
+  }
+  else {
+    hasLowerLimitRoll = Standard_False;
+    aLowerLimitRoll = 0;
+  }
+
+  Standard_Real aUpperLimitRoll;
+  Standard_Boolean hasUpperLimitRoll = Standard_True;
+  if ( theData->IsParamDefined (theNum,15) ) {
+    theData->ReadReal (theNum, 15, "upper_limit_roll", theArch, aUpperLimitRoll);
+  }
+  else {
+    hasUpperLimitRoll = Standard_False;
+    aUpperLimitRoll = 0;
+  }
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aItemDefinedTransformation_Name,
+            hasItemDefinedTransformation_Description,
+            aItemDefinedTransformation_Description,
+            aItemDefinedTransformation_TransformItem1,
+            aItemDefinedTransformation_TransformItem2,
+            aKinematicPair_Joint,
+            aPointOnPlanarCurvePair_PairCurve,
+            aPointOnPlanarCurvePair_Orientation,
+            aRangeOnPairCurve,
+            hasLowerLimitYaw,
+            aLowerLimitYaw,
+            hasUpperLimitYaw,
+            aUpperLimitYaw,
+            hasLowerLimitPitch,
+            aLowerLimitPitch,
+            hasUpperLimitPitch,
+            aUpperLimitPitch,
+            hasLowerLimitRoll,
+            aLowerLimitRoll,
+            hasUpperLimitRoll,
+            aUpperLimitRoll);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPointOnPlanarCurvePairWithRange::WriteStep (StepData_StepWriter& theSW,
+                                                                    const Handle(StepKinematics_PointOnPlanarCurvePairWithRange)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Inherited fields of ItemDefinedTransformation
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+  if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+    theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+  }
+  else theSW.SendUndef();
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Own fields of KinematicPair
+
+  theSW.Send (theEnt->Joint());
+
+  // Own fields of PointOnPlanarCurvePair
+
+  theSW.Send (theEnt->PairCurve());
+
+  theSW.SendBoolean (theEnt->Orientation());
+
+  // Own fields of PointOnPlanarCurvePairWithRange
+
+  theSW.Send (theEnt->RangeOnPairCurve());
+
+  if ( theEnt->HasLowerLimitYaw() ) {
+    theSW.Send (theEnt->LowerLimitYaw());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasUpperLimitYaw() ) {
+    theSW.Send (theEnt->UpperLimitYaw());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasLowerLimitPitch() ) {
+    theSW.Send (theEnt->LowerLimitPitch());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasUpperLimitPitch() ) {
+    theSW.Send (theEnt->UpperLimitPitch());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasLowerLimitRoll() ) {
+    theSW.Send (theEnt->LowerLimitRoll());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasUpperLimitRoll() ) {
+    theSW.Send (theEnt->UpperLimitRoll());
+  }
+  else theSW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPointOnPlanarCurvePairWithRange::Share (const Handle(StepKinematics_PointOnPlanarCurvePairWithRange)& theEnt,
+                                                                Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of ItemDefinedTransformation
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Inherited fields of KinematicPair
+
+  iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+  // Inherited fields of PointOnPlanarCurvePair
+
+  iter.AddItem (theEnt->StepKinematics_PointOnPlanarCurvePair::PairCurve());
+
+  // Own fields of PointOnPlanarCurvePairWithRange
+
+  iter.AddItem (theEnt->RangeOnPairCurve());
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PointOnPlanarCurvePairWithRange;
+
+//! Read & Write tool for PointOnPlanarCurvePairWithRange
+class RWStepKinematics_RWPointOnPlanarCurvePairWithRange
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWPointOnPlanarCurvePairWithRange();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PointOnPlanarCurvePairWithRange)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PointOnPlanarCurvePairWithRange)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_PointOnPlanarCurvePairWithRange)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPointOnPlanarCurvePairWithRange_HeaderFile_

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 <RWStepKinematics_RWPointOnSurfacePair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PointOnSurfacePair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Surface.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPointOnSurfacePair
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWPointOnSurfacePair::RWStepKinematics_RWPointOnSurfacePair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPointOnSurfacePair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                      const Standard_Integer theNum,
+                                                      Handle(Interface_Check)& theArch,
+                                                      const Handle(StepKinematics_PointOnSurfacePair)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,7,theArch,"point_on_surface_pair") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of ItemDefinedTransformation
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+  theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+  Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+  if ( theData->IsParamDefined (theNum,3) ) {
+    theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+  }
+  else {
+    hasItemDefinedTransformation_Description = Standard_False;
+    aItemDefinedTransformation_Description.Nullify();
+  }
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+  theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+  theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+  // Inherited fields of KinematicPair
+
+  Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+  theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+  // Own fields of PointOnSurfacePair
+
+  Handle(StepGeom_Surface) aPairSurface;
+  theData->ReadEntity (theNum, 7, "pair_surface", theArch, STANDARD_TYPE(StepGeom_Surface), aPairSurface);
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aItemDefinedTransformation_Name,
+            hasItemDefinedTransformation_Description,
+            aItemDefinedTransformation_Description,
+            aItemDefinedTransformation_TransformItem1,
+            aItemDefinedTransformation_TransformItem2,
+            aKinematicPair_Joint,
+            aPairSurface);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPointOnSurfacePair::WriteStep (StepData_StepWriter& theSW,
+                                                       const Handle(StepKinematics_PointOnSurfacePair)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Inherited fields of ItemDefinedTransformation
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+  if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+    theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+  }
+  else theSW.SendUndef();
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Own fields of KinematicPair
+
+  theSW.Send (theEnt->Joint());
+
+  // Own fields of PointOnSurfacePair
+
+  theSW.Send (theEnt->PairSurface());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPointOnSurfacePair::Share (const Handle(StepKinematics_PointOnSurfacePair)& theEnt,
+                                                   Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of ItemDefinedTransformation
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Inherited fields of KinematicPair
+
+  iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+  // Own fields of PointOnSurfacePair
+
+  iter.AddItem (theEnt->PairSurface());
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PointOnSurfacePair;
+
+//! Read & Write tool for PointOnSurfacePair
+class RWStepKinematics_RWPointOnSurfacePair
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWPointOnSurfacePair();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PointOnSurfacePair)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PointOnSurfacePair)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_PointOnSurfacePair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPointOnSurfacePair_HeaderFile_

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 <RWStepKinematics_RWPointOnSurfacePairValue.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PointOnSurfacePairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <StepGeom_PointOnSurface.hxx>
+#include <StepKinematics_SpatialRotation.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPointOnSurfacePairValue
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWPointOnSurfacePairValue::RWStepKinematics_RWPointOnSurfacePairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPointOnSurfacePairValue::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                           const Standard_Integer theNum,
+                                                           Handle(Interface_Check)& theArch,
+                                                           const Handle(StepKinematics_PointOnSurfacePairValue)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,4,theArch,"point_on_surface_pair_value") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of PairValue
+
+  Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+  theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+  // Own fields of PointOnSurfacePairValue
+
+  Handle(StepGeom_PointOnSurface) aActualPointOnSurface;
+  theData->ReadEntity (theNum, 3, "actual_point_on_surface", theArch, STANDARD_TYPE(StepGeom_PointOnSurface), aActualPointOnSurface);
+
+  StepKinematics_SpatialRotation aInputOrientation;
+  if (theData->SubListNumber(theNum, 4, Standard_True))
+  {
+    Handle(TColStd_HArray1OfReal) aItems;
+    Standard_Integer nsub = 0;
+    if (theData->ReadSubList(theNum, 4, "items", theArch, nsub)) {
+      Standard_Integer nb = theData->NbParams(nsub);
+      aItems = new TColStd_HArray1OfReal(1, nb);
+      Standard_Integer num2 = nsub;
+      for (Standard_Integer i0 = 1; i0 <= nb; i0++) {
+        Standard_Real anIt0;
+        theData->ReadReal(num2, i0, "real", theArch, anIt0);
+        aItems->SetValue(i0, anIt0);
+      }
+    }
+    aInputOrientation.SetValue(aItems);
+  }
+  else
+    theData->ReadEntity(theNum, 4, "input_orientation", theArch, aInputOrientation);
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aPairValue_AppliesToPair,
+            aActualPointOnSurface,
+            aInputOrientation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPointOnSurfacePairValue::WriteStep (StepData_StepWriter& theSW,
+                                                            const Handle(StepKinematics_PointOnSurfacePairValue)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Own fields of PairValue
+
+  theSW.Send (theEnt->AppliesToPair());
+
+  // Own fields of PointOnSurfacePairValue
+
+  theSW.Send (theEnt->ActualPointOnSurface());
+
+  if (!theEnt->InputOrientation().YprRotation().IsNull())
+  {
+    // Inherited field : YPR
+    theSW.OpenSub();
+    for (Standard_Integer i = 1; i <= theEnt->InputOrientation().YprRotation()->Length(); i++) {
+      theSW.Send(theEnt->InputOrientation().YprRotation()->Value(i));
+    }
+    theSW.CloseSub();
+  }
+  else
+    theSW.Send(theEnt->InputOrientation().Value());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPointOnSurfacePairValue::Share (const Handle(StepKinematics_PointOnSurfacePairValue)& theEnt,
+                                                        Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of PairValue
+
+  iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair());
+
+  // Own fields of PointOnSurfacePairValue
+
+  iter.AddItem (theEnt->ActualPointOnSurface());
+
+  if (!theEnt->InputOrientation().RotationAboutDirection().IsNull())
+    iter.AddItem(theEnt->InputOrientation().Value());
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PointOnSurfacePairValue;
+
+//! Read & Write tool for PointOnSurfacePairValue
+class RWStepKinematics_RWPointOnSurfacePairValue
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWPointOnSurfacePairValue();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PointOnSurfacePairValue)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PointOnSurfacePairValue)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_PointOnSurfacePairValue)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPointOnSurfacePairValue_HeaderFile_

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 <RWStepKinematics_RWPointOnSurfacePairWithRange.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PointOnSurfacePairWithRange.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <StepGeom_Surface.hxx>
+#include <StepGeom_RectangularTrimmedSurface.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPointOnSurfacePairWithRange
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWPointOnSurfacePairWithRange::RWStepKinematics_RWPointOnSurfacePairWithRange() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPointOnSurfacePairWithRange::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                               const Standard_Integer theNum,
+                                                               Handle(Interface_Check)& theArch,
+                                                               const Handle(StepKinematics_PointOnSurfacePairWithRange)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,14,theArch,"point_on_surface_pair_with_range") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of ItemDefinedTransformation
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+  theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+  Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+  if ( theData->IsParamDefined (theNum,3) ) {
+    theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+  }
+  else {
+    hasItemDefinedTransformation_Description = Standard_False;
+    aItemDefinedTransformation_Description.Nullify();
+  }
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+  theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+  theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+  // Inherited fields of KinematicPair
+
+  Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+  theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+  // Inherited fields of PointOnSurfacePair
+
+  Handle(StepGeom_Surface) aPointOnSurfacePair_PairSurface;
+  theData->ReadEntity (theNum, 7, "point_on_surface_pair.pair_surface", theArch, STANDARD_TYPE(StepGeom_Surface), aPointOnSurfacePair_PairSurface);
+
+  // Own fields of PointOnSurfacePairWithRange
+
+  Handle(StepGeom_RectangularTrimmedSurface) aRangeOnPairSurface;
+  theData->ReadEntity (theNum, 8, "range_on_pair_surface", theArch, STANDARD_TYPE(StepGeom_RectangularTrimmedSurface), aRangeOnPairSurface);
+
+  Standard_Real aLowerLimitYaw;
+  Standard_Boolean hasLowerLimitYaw = Standard_True;
+  if ( theData->IsParamDefined (theNum,9) ) {
+    theData->ReadReal (theNum, 9, "lower_limit_yaw", theArch, aLowerLimitYaw);
+  }
+  else {
+    hasLowerLimitYaw = Standard_False;
+    aLowerLimitYaw = 0;
+  }
+
+  Standard_Real aUpperLimitYaw;
+  Standard_Boolean hasUpperLimitYaw = Standard_True;
+  if ( theData->IsParamDefined (theNum,10) ) {
+    theData->ReadReal (theNum, 10, "upper_limit_yaw", theArch, aUpperLimitYaw);
+  }
+  else {
+    hasUpperLimitYaw = Standard_False;
+    aUpperLimitYaw = 0;
+  }
+
+  Standard_Real aLowerLimitPitch;
+  Standard_Boolean hasLowerLimitPitch = Standard_True;
+  if ( theData->IsParamDefined (theNum,11) ) {
+    theData->ReadReal (theNum, 11, "lower_limit_pitch", theArch, aLowerLimitPitch);
+  }
+  else {
+    hasLowerLimitPitch = Standard_False;
+    aLowerLimitPitch = 0;
+  }
+
+  Standard_Real aUpperLimitPitch;
+  Standard_Boolean hasUpperLimitPitch = Standard_True;
+  if ( theData->IsParamDefined (theNum,12) ) {
+    theData->ReadReal (theNum, 12, "upper_limit_pitch", theArch, aUpperLimitPitch);
+  }
+  else {
+    hasUpperLimitPitch = Standard_False;
+    aUpperLimitPitch = 0;
+  }
+
+  Standard_Real aLowerLimitRoll;
+  Standard_Boolean hasLowerLimitRoll = Standard_True;
+  if ( theData->IsParamDefined (theNum,13) ) {
+    theData->ReadReal (theNum, 13, "lower_limit_roll", theArch, aLowerLimitRoll);
+  }
+  else {
+    hasLowerLimitRoll = Standard_False;
+    aLowerLimitRoll = 0;
+  }
+
+  Standard_Real aUpperLimitRoll;
+  Standard_Boolean hasUpperLimitRoll = Standard_True;
+  if ( theData->IsParamDefined (theNum,14) ) {
+    theData->ReadReal (theNum, 14, "upper_limit_roll", theArch, aUpperLimitRoll);
+  }
+  else {
+    hasUpperLimitRoll = Standard_False;
+    aUpperLimitRoll = 0;
+  }
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aItemDefinedTransformation_Name,
+            hasItemDefinedTransformation_Description,
+            aItemDefinedTransformation_Description,
+            aItemDefinedTransformation_TransformItem1,
+            aItemDefinedTransformation_TransformItem2,
+            aKinematicPair_Joint,
+            aPointOnSurfacePair_PairSurface,
+            aRangeOnPairSurface,
+            hasLowerLimitYaw,
+            aLowerLimitYaw,
+            hasUpperLimitYaw,
+            aUpperLimitYaw,
+            hasLowerLimitPitch,
+            aLowerLimitPitch,
+            hasUpperLimitPitch,
+            aUpperLimitPitch,
+            hasLowerLimitRoll,
+            aLowerLimitRoll,
+            hasUpperLimitRoll,
+            aUpperLimitRoll);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPointOnSurfacePairWithRange::WriteStep (StepData_StepWriter& theSW,
+                                                                const Handle(StepKinematics_PointOnSurfacePairWithRange)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Inherited fields of ItemDefinedTransformation
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+  if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+    theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+  }
+  else theSW.SendUndef();
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Own fields of KinematicPair
+
+  theSW.Send (theEnt->Joint());
+
+  // Own fields of PointOnSurfacePair
+
+  theSW.Send (theEnt->PairSurface());
+
+  // Own fields of PointOnSurfacePairWithRange
+
+  theSW.Send (theEnt->RangeOnPairSurface());
+
+  if ( theEnt->HasLowerLimitYaw() ) {
+    theSW.Send (theEnt->LowerLimitYaw());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasUpperLimitYaw() ) {
+    theSW.Send (theEnt->UpperLimitYaw());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasLowerLimitPitch() ) {
+    theSW.Send (theEnt->LowerLimitPitch());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasUpperLimitPitch() ) {
+    theSW.Send (theEnt->UpperLimitPitch());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasLowerLimitRoll() ) {
+    theSW.Send (theEnt->LowerLimitRoll());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasUpperLimitRoll() ) {
+    theSW.Send (theEnt->UpperLimitRoll());
+  }
+  else theSW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPointOnSurfacePairWithRange::Share (const Handle(StepKinematics_PointOnSurfacePairWithRange)& theEnt,
+                                                            Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of ItemDefinedTransformation
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Inherited fields of KinematicPair
+
+  iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+  // Inherited fields of PointOnSurfacePair
+
+  iter.AddItem (theEnt->StepKinematics_PointOnSurfacePair::PairSurface());
+
+  // Own fields of PointOnSurfacePairWithRange
+
+  iter.AddItem (theEnt->RangeOnPairSurface());
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PointOnSurfacePairWithRange;
+
+//! Read & Write tool for PointOnSurfacePairWithRange
+class RWStepKinematics_RWPointOnSurfacePairWithRange
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWPointOnSurfacePairWithRange();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PointOnSurfacePairWithRange)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PointOnSurfacePairWithRange)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_PointOnSurfacePairWithRange)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPointOnSurfacePairWithRange_HeaderFile_

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 <RWStepKinematics_RWPrismaticPair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PrismaticPair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPrismaticPair
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWPrismaticPair::RWStepKinematics_RWPrismaticPair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPrismaticPair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                 const Standard_Integer theNum,
+                                                 Handle(Interface_Check)& theArch,
+                                                 const Handle(StepKinematics_PrismaticPair)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,12,theArch,"prismatic_pair") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of ItemDefinedTransformation
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+  theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+  Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+  if ( theData->IsParamDefined (theNum,3) ) {
+    theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+  }
+  else {
+    hasItemDefinedTransformation_Description = Standard_False;
+    aItemDefinedTransformation_Description.Nullify();
+  }
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+  theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+  theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+  // Inherited fields of KinematicPair
+
+  Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+  theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+  // Inherited fields of LowOrderKinematicPair
+
+  Standard_Boolean aLowOrderKinematicPair_TX;
+  theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX);
+
+  Standard_Boolean aLowOrderKinematicPair_TY;
+  theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY);
+
+  Standard_Boolean aLowOrderKinematicPair_TZ;
+  theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ);
+
+  Standard_Boolean aLowOrderKinematicPair_RX;
+  theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX);
+
+  Standard_Boolean aLowOrderKinematicPair_RY;
+  theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY);
+
+  Standard_Boolean aLowOrderKinematicPair_RZ;
+  theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ);
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aItemDefinedTransformation_Name,
+            hasItemDefinedTransformation_Description,
+            aItemDefinedTransformation_Description,
+            aItemDefinedTransformation_TransformItem1,
+            aItemDefinedTransformation_TransformItem2,
+            aKinematicPair_Joint,
+            aLowOrderKinematicPair_TX,
+            aLowOrderKinematicPair_TY,
+            aLowOrderKinematicPair_TZ,
+            aLowOrderKinematicPair_RX,
+            aLowOrderKinematicPair_RY,
+            aLowOrderKinematicPair_RZ);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPrismaticPair::WriteStep (StepData_StepWriter& theSW,
+                                                  const Handle(StepKinematics_PrismaticPair)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Inherited fields of ItemDefinedTransformation
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+  if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+    theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+  }
+  else theSW.SendUndef();
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Own fields of KinematicPair
+
+  theSW.Send (theEnt->Joint());
+
+  // Own fields of LowOrderKinematicPair
+
+  theSW.SendBoolean (theEnt->TX());
+
+  theSW.SendBoolean (theEnt->TY());
+
+  theSW.SendBoolean (theEnt->TZ());
+
+  theSW.SendBoolean (theEnt->RX());
+
+  theSW.SendBoolean (theEnt->RY());
+
+  theSW.SendBoolean (theEnt->RZ());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPrismaticPair::Share (const Handle(StepKinematics_PrismaticPair)& theEnt,
+                                              Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of ItemDefinedTransformation
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Inherited fields of KinematicPair
+
+  iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+  // Inherited fields of LowOrderKinematicPair
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PrismaticPair;
+
+//! Read & Write tool for PrismaticPair
+class RWStepKinematics_RWPrismaticPair
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWPrismaticPair();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PrismaticPair)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PrismaticPair)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_PrismaticPair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPrismaticPair_HeaderFile_

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 <RWStepKinematics_RWPrismaticPairValue.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PrismaticPairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPrismaticPairValue
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWPrismaticPairValue::RWStepKinematics_RWPrismaticPairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPrismaticPairValue::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                      const Standard_Integer theNum,
+                                                      Handle(Interface_Check)& theArch,
+                                                      const Handle(StepKinematics_PrismaticPairValue)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,3,theArch,"prismatic_pair_value") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of PairValue
+
+  Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+  theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+  // Own fields of PrismaticPairValue
+
+  Standard_Real aActualTranslation;
+  theData->ReadReal (theNum, 3, "actual_translation", theArch, aActualTranslation);
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aPairValue_AppliesToPair,
+            aActualTranslation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPrismaticPairValue::WriteStep (StepData_StepWriter& theSW,
+                                                       const Handle(StepKinematics_PrismaticPairValue)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Own fields of PairValue
+
+  theSW.Send (theEnt->AppliesToPair());
+
+  // Own fields of PrismaticPairValue
+
+  theSW.Send (theEnt->ActualTranslation());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPrismaticPairValue::Share (const Handle(StepKinematics_PrismaticPairValue)& theEnt,
+                                                   Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of PairValue
+
+  iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair());
+
+  // Own fields of PrismaticPairValue
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PrismaticPairValue;
+
+//! Read & Write tool for PrismaticPairValue
+class RWStepKinematics_RWPrismaticPairValue
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWPrismaticPairValue();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PrismaticPairValue)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PrismaticPairValue)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_PrismaticPairValue)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPrismaticPairValue_HeaderFile_

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 <RWStepKinematics_RWPrismaticPairWithRange.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_PrismaticPairWithRange.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Boolean.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWPrismaticPairWithRange
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWPrismaticPairWithRange::RWStepKinematics_RWPrismaticPairWithRange() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPrismaticPairWithRange::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                          const Standard_Integer theNum,
+                                                          Handle(Interface_Check)& theArch,
+                                                          const Handle(StepKinematics_PrismaticPairWithRange)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,14,theArch,"prismatic_pair_with_range") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of ItemDefinedTransformation
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+  theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+  Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+  if ( theData->IsParamDefined (theNum,3) ) {
+    theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+  }
+  else {
+    hasItemDefinedTransformation_Description = Standard_False;
+    aItemDefinedTransformation_Description.Nullify();
+  }
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+  theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+  theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+  // Inherited fields of KinematicPair
+
+  Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+  theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+  // Inherited fields of LowOrderKinematicPair
+
+  Standard_Boolean aLowOrderKinematicPair_TX;
+  theData->ReadBoolean (theNum, 7, "low_order_kinematic_pair.t_x", theArch, aLowOrderKinematicPair_TX);
+
+  Standard_Boolean aLowOrderKinematicPair_TY;
+  theData->ReadBoolean (theNum, 8, "low_order_kinematic_pair.t_y", theArch, aLowOrderKinematicPair_TY);
+
+  Standard_Boolean aLowOrderKinematicPair_TZ;
+  theData->ReadBoolean (theNum, 9, "low_order_kinematic_pair.t_z", theArch, aLowOrderKinematicPair_TZ);
+
+  Standard_Boolean aLowOrderKinematicPair_RX;
+  theData->ReadBoolean (theNum, 10, "low_order_kinematic_pair.r_x", theArch, aLowOrderKinematicPair_RX);
+
+  Standard_Boolean aLowOrderKinematicPair_RY;
+  theData->ReadBoolean (theNum, 11, "low_order_kinematic_pair.r_y", theArch, aLowOrderKinematicPair_RY);
+
+  Standard_Boolean aLowOrderKinematicPair_RZ;
+  theData->ReadBoolean (theNum, 12, "low_order_kinematic_pair.r_z", theArch, aLowOrderKinematicPair_RZ);
+
+  // Own fields of PrismaticPairWithRange
+
+  Standard_Real aLowerLimitActualTranslation;
+  Standard_Boolean hasLowerLimitActualTranslation = Standard_True;
+  if ( theData->IsParamDefined (theNum,13) ) {
+    theData->ReadReal (theNum, 13, "lower_limit_actual_translation", theArch, aLowerLimitActualTranslation);
+  }
+  else {
+    hasLowerLimitActualTranslation = Standard_False;
+    aLowerLimitActualTranslation = 0;
+  }
+
+  Standard_Real aUpperLimitActualTranslation;
+  Standard_Boolean hasUpperLimitActualTranslation = Standard_True;
+  if ( theData->IsParamDefined (theNum,14) ) {
+    theData->ReadReal (theNum, 14, "upper_limit_actual_translation", theArch, aUpperLimitActualTranslation);
+  }
+  else {
+    hasUpperLimitActualTranslation = Standard_False;
+    aUpperLimitActualTranslation = 0;
+  }
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aItemDefinedTransformation_Name,
+            hasItemDefinedTransformation_Description,
+            aItemDefinedTransformation_Description,
+            aItemDefinedTransformation_TransformItem1,
+            aItemDefinedTransformation_TransformItem2,
+            aKinematicPair_Joint,
+            aLowOrderKinematicPair_TX,
+            aLowOrderKinematicPair_TY,
+            aLowOrderKinematicPair_TZ,
+            aLowOrderKinematicPair_RX,
+            aLowOrderKinematicPair_RY,
+            aLowOrderKinematicPair_RZ,
+            hasLowerLimitActualTranslation,
+            aLowerLimitActualTranslation,
+            hasUpperLimitActualTranslation,
+            aUpperLimitActualTranslation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPrismaticPairWithRange::WriteStep (StepData_StepWriter& theSW,
+                                                           const Handle(StepKinematics_PrismaticPairWithRange)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Inherited fields of ItemDefinedTransformation
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+  if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+    theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+  }
+  else theSW.SendUndef();
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Own fields of KinematicPair
+
+  theSW.Send (theEnt->Joint());
+
+  // Own fields of LowOrderKinematicPair
+
+  theSW.SendBoolean (theEnt->TX());
+
+  theSW.SendBoolean (theEnt->TY());
+
+  theSW.SendBoolean (theEnt->TZ());
+
+  theSW.SendBoolean (theEnt->RX());
+
+  theSW.SendBoolean (theEnt->RY());
+
+  theSW.SendBoolean (theEnt->RZ());
+
+  // Own fields of PrismaticPairWithRange
+
+  if ( theEnt->HasLowerLimitActualTranslation() ) {
+    theSW.Send (theEnt->LowerLimitActualTranslation());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasUpperLimitActualTranslation() ) {
+    theSW.Send (theEnt->UpperLimitActualTranslation());
+  }
+  else theSW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWPrismaticPairWithRange::Share (const Handle(StepKinematics_PrismaticPairWithRange)& theEnt,
+                                                       Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of ItemDefinedTransformation
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Inherited fields of KinematicPair
+
+  iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+  // Inherited fields of LowOrderKinematicPair
+
+  // Own fields of PrismaticPairWithRange
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_PrismaticPairWithRange;
+
+//! Read & Write tool for PrismaticPairWithRange
+class RWStepKinematics_RWPrismaticPairWithRange
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWPrismaticPairWithRange();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_PrismaticPairWithRange)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_PrismaticPairWithRange)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_PrismaticPairWithRange)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWPrismaticPairWithRange_HeaderFile_

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 <RWStepKinematics_RWProductDefinitionKinematics.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_ProductDefinitionKinematics.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_CharacterizedDefinition.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWProductDefinitionKinematics
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWProductDefinitionKinematics::RWStepKinematics_RWProductDefinitionKinematics() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWProductDefinitionKinematics::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                               const Standard_Integer theNum,
+                                                               Handle(Interface_Check)& theArch,
+                                                               const Handle(StepKinematics_ProductDefinitionKinematics)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,3,theArch,"product_definition_kinematics") ) return;
+
+  // Inherited fields of PropertyDefinition
+
+  Handle(TCollection_HAsciiString) aPropertyDefinition_Name;
+  theData->ReadString (theNum, 1, "property_definition.name", theArch, aPropertyDefinition_Name);
+
+  Handle(TCollection_HAsciiString) aPropertyDefinition_Description;
+  Standard_Boolean hasPropertyDefinition_Description = Standard_True;
+  if ( theData->IsParamDefined (theNum,2) ) {
+    theData->ReadString (theNum, 2, "property_definition.description", theArch, aPropertyDefinition_Description);
+  }
+  else {
+    hasPropertyDefinition_Description = Standard_False;
+    aPropertyDefinition_Description.Nullify();
+  }
+
+  StepRepr_CharacterizedDefinition aPropertyDefinition_Definition;
+  theData->ReadEntity (theNum, 3, "property_definition.definition", theArch, aPropertyDefinition_Definition);
+
+  // Initialize entity
+  theEnt->Init(aPropertyDefinition_Name,
+            hasPropertyDefinition_Description,
+            aPropertyDefinition_Description,
+            aPropertyDefinition_Definition);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWProductDefinitionKinematics::WriteStep (StepData_StepWriter& theSW,
+                                                                const Handle(StepKinematics_ProductDefinitionKinematics)& theEnt) const
+{
+
+  // Own fields of PropertyDefinition
+
+  theSW.Send (theEnt->Name());
+
+  if ( theEnt->HasDescription() ) {
+    theSW.Send (theEnt->Description());
+  }
+  else theSW.SendUndef();
+
+  theSW.Send (theEnt->Definition().Value());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWProductDefinitionKinematics::Share (const Handle(StepKinematics_ProductDefinitionKinematics)& theEnt,
+                                                            Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of PropertyDefinition
+
+  iter.AddItem (theEnt->StepRepr_PropertyDefinition::Definition().Value());
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_ProductDefinitionKinematics;
+
+//! Read & Write tool for ProductDefinitionKinematics
+class RWStepKinematics_RWProductDefinitionKinematics
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWProductDefinitionKinematics();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_ProductDefinitionKinematics)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_ProductDefinitionKinematics)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_ProductDefinitionKinematics)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWProductDefinitionKinematics_HeaderFile_

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 <RWStepKinematics_RWProductDefinitionRelationshipKinematics.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_ProductDefinitionRelationshipKinematics.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_CharacterizedDefinition.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWProductDefinitionRelationshipKinematics
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWProductDefinitionRelationshipKinematics::RWStepKinematics_RWProductDefinitionRelationshipKinematics() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWProductDefinitionRelationshipKinematics::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                                           const Standard_Integer theNum,
+                                                                           Handle(Interface_Check)& theArch,
+                                                                           const Handle(StepKinematics_ProductDefinitionRelationshipKinematics)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,3,theArch,"product_definition_relationship_kinematics") ) return;
+
+  // Inherited fields of PropertyDefinition
+
+  Handle(TCollection_HAsciiString) aPropertyDefinition_Name;
+  theData->ReadString (theNum, 1, "property_definition.name", theArch, aPropertyDefinition_Name);
+
+  Handle(TCollection_HAsciiString) aPropertyDefinition_Description;
+  Standard_Boolean hasPropertyDefinition_Description = Standard_True;
+  if ( theData->IsParamDefined (theNum,2) ) {
+    theData->ReadString (theNum, 2, "property_definition.description", theArch, aPropertyDefinition_Description);
+  }
+  else {
+    hasPropertyDefinition_Description = Standard_False;
+    aPropertyDefinition_Description.Nullify();
+  }
+
+  StepRepr_CharacterizedDefinition aPropertyDefinition_Definition;
+  theData->ReadEntity (theNum, 3, "property_definition.definition", theArch, aPropertyDefinition_Definition);
+
+  // Initialize entity
+  theEnt->Init(aPropertyDefinition_Name,
+            hasPropertyDefinition_Description,
+            aPropertyDefinition_Description,
+            aPropertyDefinition_Definition);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWProductDefinitionRelationshipKinematics::WriteStep (StepData_StepWriter& theSW,
+                                                                            const Handle(StepKinematics_ProductDefinitionRelationshipKinematics)& theEnt) const
+{
+
+  // Own fields of PropertyDefinition
+
+  theSW.Send (theEnt->Name());
+
+  if ( theEnt->HasDescription() ) {
+    theSW.Send (theEnt->Description());
+  }
+  else theSW.SendUndef();
+
+  theSW.Send (theEnt->Definition().Value());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWProductDefinitionRelationshipKinematics::Share (const Handle(StepKinematics_ProductDefinitionRelationshipKinematics)& theEnt,
+                                                                        Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of PropertyDefinition
+
+  iter.AddItem (theEnt->StepRepr_PropertyDefinition::Definition().Value());
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_ProductDefinitionRelationshipKinematics;
+
+//! Read & Write tool for ProductDefinitionRelationshipKinematics
+class RWStepKinematics_RWProductDefinitionRelationshipKinematics
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWProductDefinitionRelationshipKinematics();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_ProductDefinitionRelationshipKinematics)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_ProductDefinitionRelationshipKinematics)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_ProductDefinitionRelationshipKinematics)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWProductDefinitionRelationshipKinematics_HeaderFile_

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 <RWStepKinematics_RWRackAndPinionPair.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_RackAndPinionPair.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWRackAndPinionPair
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWRackAndPinionPair::RWStepKinematics_RWRackAndPinionPair() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWRackAndPinionPair::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                     const Standard_Integer theNum,
+                                                     Handle(Interface_Check)& theArch,
+                                                     const Handle(StepKinematics_RackAndPinionPair)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,7,theArch,"rack_and_pinion_pair") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of ItemDefinedTransformation
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+  theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+  Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+  if ( theData->IsParamDefined (theNum,3) ) {
+    theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+  }
+  else {
+    hasItemDefinedTransformation_Description = Standard_False;
+    aItemDefinedTransformation_Description.Nullify();
+  }
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+  theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+  theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+  // Inherited fields of KinematicPair
+
+  Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+  theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+  // Own fields of RackAndPinionPair
+
+  Standard_Real aPinionRadius;
+  theData->ReadReal (theNum, 7, "pinion_radius", theArch, aPinionRadius);
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aItemDefinedTransformation_Name,
+            hasItemDefinedTransformation_Description,
+            aItemDefinedTransformation_Description,
+            aItemDefinedTransformation_TransformItem1,
+            aItemDefinedTransformation_TransformItem2,
+            aKinematicPair_Joint,
+            aPinionRadius);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWRackAndPinionPair::WriteStep (StepData_StepWriter& theSW,
+                                                      const Handle(StepKinematics_RackAndPinionPair)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Inherited fields of ItemDefinedTransformation
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+  if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+    theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+  }
+  else theSW.SendUndef();
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Own fields of KinematicPair
+
+  theSW.Send (theEnt->Joint());
+
+  // Own fields of RackAndPinionPair
+
+  theSW.Send (theEnt->PinionRadius());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWRackAndPinionPair::Share (const Handle(StepKinematics_RackAndPinionPair)& theEnt,
+                                                  Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of ItemDefinedTransformation
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Inherited fields of KinematicPair
+
+  iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+  // Own fields of RackAndPinionPair
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_RackAndPinionPair;
+
+//! Read & Write tool for RackAndPinionPair
+class RWStepKinematics_RWRackAndPinionPair
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWRackAndPinionPair();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_RackAndPinionPair)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_RackAndPinionPair)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_RackAndPinionPair)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWRackAndPinionPair_HeaderFile_

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 <RWStepKinematics_RWRackAndPinionPairValue.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_RackAndPinionPairValue.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepKinematics_KinematicPair.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWRackAndPinionPairValue
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWRackAndPinionPairValue::RWStepKinematics_RWRackAndPinionPairValue() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWRackAndPinionPairValue::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                          const Standard_Integer theNum,
+                                                          Handle(Interface_Check)& theArch,
+                                                          const Handle(StepKinematics_RackAndPinionPairValue)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,3,theArch,"rack_and_pinion_pair_value") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of PairValue
+
+  Handle(StepKinematics_KinematicPair) aPairValue_AppliesToPair;
+  theData->ReadEntity (theNum, 2, "pair_value.applies_to_pair", theArch, STANDARD_TYPE(StepKinematics_KinematicPair), aPairValue_AppliesToPair);
+
+  // Own fields of RackAndPinionPairValue
+
+  Standard_Real aActualDisplacement;
+  theData->ReadReal (theNum, 3, "actual_displacement", theArch, aActualDisplacement);
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aPairValue_AppliesToPair,
+            aActualDisplacement);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWRackAndPinionPairValue::WriteStep (StepData_StepWriter& theSW,
+                                                           const Handle(StepKinematics_RackAndPinionPairValue)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Own fields of PairValue
+
+  theSW.Send (theEnt->AppliesToPair());
+
+  // Own fields of RackAndPinionPairValue
+
+  theSW.Send (theEnt->ActualDisplacement());
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWRackAndPinionPairValue::Share (const Handle(StepKinematics_RackAndPinionPairValue)& theEnt,
+                                                       Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of PairValue
+
+  iter.AddItem (theEnt->StepKinematics_PairValue::AppliesToPair());
+
+  // Own fields of RackAndPinionPairValue
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_RackAndPinionPairValue;
+
+//! Read & Write tool for RackAndPinionPairValue
+class RWStepKinematics_RWRackAndPinionPairValue
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWRackAndPinionPairValue();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_RackAndPinionPairValue)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_RackAndPinionPairValue)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_RackAndPinionPairValue)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWRackAndPinionPairValue_HeaderFile_

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 <RWStepKinematics_RWRackAndPinionPairWithRange.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepKinematics_RackAndPinionPairWithRange.hxx>
+#include <TCollection_HAsciiString.hxx>
+#include <StepRepr_ItemDefinedTransformation.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepKinematics_KinematicJoint.hxx>
+#include <Standard_Real.hxx>
+
+//=======================================================================
+//function : RWStepKinematics_RWRackAndPinionPairWithRange
+//purpose  :
+//=======================================================================
+RWStepKinematics_RWRackAndPinionPairWithRange::RWStepKinematics_RWRackAndPinionPairWithRange() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWRackAndPinionPairWithRange::ReadStep (const Handle(StepData_StepReaderData)& theData,
+                                                              const Standard_Integer theNum,
+                                                              Handle(Interface_Check)& theArch,
+                                                              const Handle(StepKinematics_RackAndPinionPairWithRange)& theEnt) const
+{
+  // Check number of parameters
+  if ( ! theData->CheckNbParams(theNum,9,theArch,"rack_and_pinion_pair_with_range") ) return;
+
+  // Inherited fields of RepresentationItem
+
+  Handle(TCollection_HAsciiString) aRepresentationItem_Name;
+  theData->ReadString (theNum, 1, "representation_item.name", theArch, aRepresentationItem_Name);
+
+  // Inherited fields of ItemDefinedTransformation
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Name;
+  theData->ReadString (theNum, 2, "item_defined_transformation.name", theArch, aItemDefinedTransformation_Name);
+
+  Handle(TCollection_HAsciiString) aItemDefinedTransformation_Description;
+  Standard_Boolean hasItemDefinedTransformation_Description = Standard_True;
+  if ( theData->IsParamDefined (theNum,3) ) {
+    theData->ReadString (theNum, 3, "item_defined_transformation.description", theArch, aItemDefinedTransformation_Description);
+  }
+  else {
+    hasItemDefinedTransformation_Description = Standard_False;
+    aItemDefinedTransformation_Description.Nullify();
+  }
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem1;
+  theData->ReadEntity (theNum, 4, "item_defined_transformation.transform_item1", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem1);
+
+  Handle(StepRepr_RepresentationItem) aItemDefinedTransformation_TransformItem2;
+  theData->ReadEntity (theNum, 5, "item_defined_transformation.transform_item2", theArch, STANDARD_TYPE(StepRepr_RepresentationItem), aItemDefinedTransformation_TransformItem2);
+
+  // Inherited fields of KinematicPair
+
+  Handle(StepKinematics_KinematicJoint) aKinematicPair_Joint;
+  theData->ReadEntity (theNum, 6, "kinematic_pair.joint", theArch, STANDARD_TYPE(StepKinematics_KinematicJoint), aKinematicPair_Joint);
+
+  // Inherited fields of RackAndPinionPair
+
+  Standard_Real aRackAndPinionPair_PinionRadius;
+  theData->ReadReal (theNum, 7, "rack_and_pinion_pair.pinion_radius", theArch, aRackAndPinionPair_PinionRadius);
+
+  // Own fields of RackAndPinionPairWithRange
+
+  Standard_Real aLowerLimitRackDisplacement;
+  Standard_Boolean hasLowerLimitRackDisplacement = Standard_True;
+  if ( theData->IsParamDefined (theNum,8) ) {
+    theData->ReadReal (theNum, 8, "lower_limit_rack_displacement", theArch, aLowerLimitRackDisplacement);
+  }
+  else {
+    hasLowerLimitRackDisplacement = Standard_False;
+    aLowerLimitRackDisplacement = 0;
+  }
+
+  Standard_Real aUpperLimitRackDisplacement;
+  Standard_Boolean hasUpperLimitRackDisplacement = Standard_True;
+  if ( theData->IsParamDefined (theNum,9) ) {
+    theData->ReadReal (theNum, 9, "upper_limit_rack_displacement", theArch, aUpperLimitRackDisplacement);
+  }
+  else {
+    hasUpperLimitRackDisplacement = Standard_False;
+    aUpperLimitRackDisplacement = 0;
+  }
+
+  // Initialize entity
+  theEnt->Init(aRepresentationItem_Name,
+            aItemDefinedTransformation_Name,
+            hasItemDefinedTransformation_Description,
+            aItemDefinedTransformation_Description,
+            aItemDefinedTransformation_TransformItem1,
+            aItemDefinedTransformation_TransformItem2,
+            aKinematicPair_Joint,
+            aRackAndPinionPair_PinionRadius,
+            hasLowerLimitRackDisplacement,
+            aLowerLimitRackDisplacement,
+            hasUpperLimitRackDisplacement,
+            aUpperLimitRackDisplacement);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWRackAndPinionPairWithRange::WriteStep (StepData_StepWriter& theSW,
+                                                               const Handle(StepKinematics_RackAndPinionPairWithRange)& theEnt) const
+{
+
+  // Own fields of RepresentationItem
+
+  theSW.Send (theEnt->Name());
+
+  // Inherited fields of ItemDefinedTransformation
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->Name());
+
+  if ( theEnt->ItemDefinedTransformation()->HasDescription() ) {
+    theSW.Send (theEnt->ItemDefinedTransformation()->Description());
+  }
+  else theSW.SendUndef();
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  theSW.Send (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Own fields of KinematicPair
+
+  theSW.Send (theEnt->Joint());
+
+  // Own fields of RackAndPinionPair
+
+  theSW.Send (theEnt->PinionRadius());
+
+  // Own fields of RackAndPinionPairWithRange
+
+  if ( theEnt->HasLowerLimitRackDisplacement() ) {
+    theSW.Send (theEnt->LowerLimitRackDisplacement());
+  }
+  else theSW.SendUndef();
+
+  if ( theEnt->HasUpperLimitRackDisplacement() ) {
+    theSW.Send (theEnt->UpperLimitRackDisplacement());
+  }
+  else theSW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose  :
+//=======================================================================
+void RWStepKinematics_RWRackAndPinionPairWithRange::Share (const Handle(StepKinematics_RackAndPinionPairWithRange)& theEnt,
+                                                           Interface_EntityIterator& iter) const
+{
+
+  // Inherited fields of RepresentationItem
+
+  // Inherited fields of ItemDefinedTransformation
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem1());
+
+  iter.AddItem (theEnt->ItemDefinedTransformation()->TransformItem2());
+
+  // Inherited fields of KinematicPair
+
+  iter.AddItem (theEnt->StepKinematics_KinematicPair::Joint());
+
+  // Inherited fields of RackAndPinionPair
+
+  // Own fields of RackAndPinionPairWithRange
+}

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 <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+class StepKinematics_RackAndPinionPairWithRange;
+
+//! Read & Write tool for RackAndPinionPairWithRange
+class RWStepKinematics_RWRackAndPinionPairWithRange
+{
+public:
+
+  DEFINE_STANDARD_ALLOC
+
+  Standard_EXPORT RWStepKinematics_RWRackAndPinionPairWithRange();
+
+  Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData, const Standard_Integer theNum, Handle(Interface_Check)& theArch, const Handle(StepKinematics_RackAndPinionPairWithRange)& theEnt) const;
+
+  Standard_EXPORT void WriteStep(StepData_StepWriter& theSW, const Handle(StepKinematics_RackAndPinionPairWithRange)& theEnt) const;
+
+  Standard_EXPORT void Share(const Handle(StepKinematics_RackAndPinionPairWithRange)& theEnt, Interface_EntityIterator& iter) const;
+
+};
+#endif // _RWStepKinematics_RWRackAndPinionPairWithRange_HeaderFile_