OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-05-16 10:54:53 +03:00
Code

0031388: Data Exchange - support kinematics data in STEP format

Browse Source 
- add new STEP entities.
This commit is contained in:
dpasukhi 2020-03-12 19:29:21 +03:00 committed by smoskvin
parent 92c1f9728e
commit 812ee2c9be
352 changed files with 34916 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
adm/UDLIST
View File

@ -328,6 +328,7 @@ n RWStepDimTol
n RWStepElement
n RWStepFEA
n RWStepGeom
n RWStepKinematics
n RWStepRepr
n RWStepShape
n RWStepVisual
@ -347,6 +348,7 @@ n StepDimTol
n StepElement
n StepFEA
n StepGeom
n StepKinematics
n StepRepr
n StepSelect
n StepShape

1008
src/RWStepAP214/RWStepAP214_GeneralModule.cxx
View File

File diff suppressed because it is too large Load Diff

1509
src/RWStepAP214/RWStepAP214_ReadWriteModule.cxx
View File

File diff suppressed because it is too large Load Diff

2
src/RWStepGeom/FILES
View File

@ -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

122
src/RWStepGeom/RWStepGeom_RWSuParameters.cxx Normal file
View File

@ -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
}

46
src/RWStepGeom/RWStepGeom_RWSuParameters.hxx Normal file
View File

@ -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_

148
src/RWStepKinematics/FILES Normal file
View File

@ -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

2309
src/RWStepKinematics/RWStepKinematics_RWActuatedKinPairAndOrderKinPair.cxx Normal file
View File

File diff suppressed because it is too large Load Diff

47
src/RWStepKinematics/RWStepKinematics_RWActuatedKinPairAndOrderKinPair.hxx Normal file
View File

@ -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

318
src/RWStepKinematics/RWStepKinematics_RWActuatedKinematicPair.cxx Normal file
View File

@ -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
}

46
src/RWStepKinematics/RWStepKinematics_RWActuatedKinematicPair.hxx Normal file
View File

@ -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_

86
src/RWStepKinematics/RWStepKinematics_RWContextDependentKinematicLinkRepresentation.cxx Normal file
View File

@ -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());
}

46
src/RWStepKinematics/RWStepKinematics_RWContextDependentKinematicLinkRepresentation.hxx Normal file
View File

@ -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_

180
src/RWStepKinematics/RWStepKinematics_RWCylindricalPair.cxx Normal file
View File

@ -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
}

46
src/RWStepKinematics/RWStepKinematics_RWCylindricalPair.hxx Normal file
View File

@ -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_

109
src/RWStepKinematics/RWStepKinematics_RWCylindricalPairValue.cxx Normal file
View File

@ -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
}

46
src/RWStepKinematics/RWStepKinematics_RWCylindricalPairValue.hxx Normal file
View File

@ -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_

255
src/RWStepKinematics/RWStepKinematics_RWCylindricalPairWithRange.cxx Normal file
View File

@ -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
}

46
src/RWStepKinematics/RWStepKinematics_RWCylindricalPairWithRange.hxx Normal file
View File

@ -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_

180
src/RWStepKinematics/RWStepKinematics_RWFullyConstrainedPair.cxx Normal file
View File

@ -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
}

46
src/RWStepKinematics/RWStepKinematics_RWFullyConstrainedPair.hxx Normal file
View File

@ -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_

174
src/RWStepKinematics/RWStepKinematics_RWGearPair.cxx Normal file
View File

@ -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
}

46
src/RWStepKinematics/RWStepKinematics_RWGearPair.hxx Normal file
View File

@ -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_

103
src/RWStepKinematics/RWStepKinematics_RWGearPairValue.cxx Normal file
View File

@ -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
}

46
src/RWStepKinematics/RWStepKinematics_RWGearPairValue.hxx Normal file
View File

@ -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_

214
src/RWStepKinematics/RWStepKinematics_RWGearPairWithRange.cxx Normal file
View File

@ -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
}

46
src/RWStepKinematics/RWStepKinematics_RWGearPairWithRange.hxx Normal file
View File

@ -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_

204
src/RWStepKinematics/RWStepKinematics_RWHomokineticPair.cxx Normal file
View File

@ -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
}

46
src/RWStepKinematics/RWStepKinematics_RWHomokineticPair.hxx Normal file
View File

@ -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_

98
src/RWStepKinematics/RWStepKinematics_RWKinematicJoint.cxx Normal file
View File

@ -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());
}

46
src/RWStepKinematics/RWStepKinematics_RWKinematicJoint.hxx Normal file
View File

@ -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_

75
src/RWStepKinematics/RWStepKinematics_RWKinematicLink.cxx Normal file
View File

@ -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
}

46
src/RWStepKinematics/RWStepKinematics_RWKinematicLink.hxx Normal file
View File

@ -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_

111
src/RWStepKinematics/RWStepKinematics_RWKinematicLinkRepresentationAssociation.cxx Normal file
View File

@ -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());
}

46
src/RWStepKinematics/RWStepKinematics_RWKinematicLinkRepresentationAssociation.hxx Normal file
View File

@ -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_

101
src/RWStepKinematics/RWStepKinematics_RWKinematicPropertyMechanismRepresentation.cxx Normal file
View File

@ -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());
}

46
src/RWStepKinematics/RWStepKinematics_RWKinematicPropertyMechanismRepresentation.hxx Normal file
View File

@ -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_

127
src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyDirectedStructure.cxx Normal file
View File

@ -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());
}

46
src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyDirectedStructure.hxx Normal file
View File

@ -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_

127
src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyNetworkStructure.cxx Normal file
View File

@ -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());
}

46
src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyNetworkStructure.hxx Normal file
View File

@ -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_

112
src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyStructure.cxx Normal file
View File

@ -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());
}

46
src/RWStepKinematics/RWStepKinematics_RWKinematicTopologyStructure.hxx Normal file
View File

@ -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_

150
src/RWStepKinematics/RWStepKinematics_RWLinearFlexibleAndPinionPair.cxx Normal file
View File

@ -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
}

46
src/RWStepKinematics/RWStepKinematics_RWLinearFlexibleAndPinionPair.hxx Normal file
View File

@ -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_

159
src/RWStepKinematics/RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair.cxx Normal file
View File

@ -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());
}

46
src/RWStepKinematics/RWStepKinematics_RWLinearFlexibleAndPlanarCurvePair.hxx Normal file
View File

@ -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_

127
src/RWStepKinematics/RWStepKinematics_RWLinearFlexibleLinkRepresentation.cxx Normal file
View File

@ -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());
}

46
src/RWStepKinematics/RWStepKinematics_RWLinearFlexibleLinkRepresentation.hxx Normal file
View File

@ -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_

180
src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPair.cxx Normal file
View File

@ -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
}

46
src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPair.hxx Normal file
View File

@ -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_

133
src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPairValue.cxx Normal file
View File

@ -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
}

46
src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPairValue.hxx Normal file
View File

@ -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_

391
src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPairWithRange.cxx Normal file
View File

@ -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
}

46
src/RWStepKinematics/RWStepKinematics_RWLowOrderKinematicPairWithRange.hxx Normal file
View File

@ -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_

128
src/RWStepKinematics/RWStepKinematics_RWMechanismRepresentation.cxx Normal file
View File

@ -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());
}

46
src/RWStepKinematics/RWStepKinematics_RWMechanismRepresentation.hxx Normal file
View File

@ -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_

117
src/RWStepKinematics/RWStepKinematics_RWMechanismStateRepresentation.cxx Normal file
View File

@ -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());
}

47
src/RWStepKinematics/RWStepKinematics_RWMechanismStateRepresentation.hxx Normal file
View File

@ -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

118
src/RWStepKinematics/RWStepKinematics_RWOrientedJoint.cxx Normal file
View File

@ -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());
}

46
src/RWStepKinematics/RWStepKinematics_RWOrientedJoint.hxx Normal file
View File

@ -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_

138
src/RWStepKinematics/RWStepKinematics_RWPairRepresentationRelationship.cxx Normal file
View File

@ -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());
}

46
src/RWStepKinematics/RWStepKinematics_RWPairRepresentationRelationship.hxx Normal file
View File

@ -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_

167
src/RWStepKinematics/RWStepKinematics_RWPlanarCurvePair.cxx Normal file
View File

@ -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());
}

46
src/RWStepKinematics/RWStepKinematics_RWPlanarCurvePair.hxx Normal file
View File

@ -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_

190
src/RWStepKinematics/RWStepKinematics_RWPlanarCurvePairRange.cxx Normal file
View File

@ -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());
}

46
src/RWStepKinematics/RWStepKinematics_RWPlanarCurvePairRange.hxx Normal file
View File

@ -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_

180
src/RWStepKinematics/RWStepKinematics_RWPlanarPair.cxx Normal file
View File

@ -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
}

46
src/RWStepKinematics/RWStepKinematics_RWPlanarPair.hxx Normal file
View File

@ -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_

115
src/RWStepKinematics/RWStepKinematics_RWPlanarPairValue.cxx Normal file
View File

@ -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
}

46
src/RWStepKinematics/RWStepKinematics_RWPlanarPairValue.hxx Normal file
View File

@ -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_

289
src/RWStepKinematics/RWStepKinematics_RWPlanarPairWithRange.cxx Normal file
View File

@ -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
}

46
src/RWStepKinematics/RWStepKinematics_RWPlanarPairWithRange.hxx Normal file
View File

@ -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_

159
src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePair.cxx Normal file
View File

@ -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());
}

46
src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePair.hxx Normal file
View File

@ -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_

142
src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePairValue.cxx Normal file
View File

@ -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());
}

46
src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePairValue.hxx Normal file
View File

@ -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_

277
src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePairWithRange.cxx Normal file
View File

@ -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());
}

46
src/RWStepKinematics/RWStepKinematics_RWPointOnPlanarCurvePairWithRange.hxx Normal file
View File

@ -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_

152
src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePair.cxx Normal file
View File

@ -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());
}

46
src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePair.hxx Normal file
View File

@ -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_

142
src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePairValue.cxx Normal file
View File

@ -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());
}

46
src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePairValue.hxx Normal file
View File

@ -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_

270
src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePairWithRange.cxx Normal file
View File

@ -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());
}

46
src/RWStepKinematics/RWStepKinematics_RWPointOnSurfacePairWithRange.hxx Normal file
View File

@ -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_

180
src/RWStepKinematics/RWStepKinematics_RWPrismaticPair.cxx Normal file
View File

@ -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
}

46
src/RWStepKinematics/RWStepKinematics_RWPrismaticPair.hxx Normal file
View File

@ -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_

103
src/RWStepKinematics/RWStepKinematics_RWPrismaticPairValue.cxx Normal file
View File

@ -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
}

46
src/RWStepKinematics/RWStepKinematics_RWPrismaticPairValue.hxx Normal file
View File

@ -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_

221
src/RWStepKinematics/RWStepKinematics_RWPrismaticPairWithRange.cxx Normal file
View File

@ -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
}

46
src/RWStepKinematics/RWStepKinematics_RWPrismaticPairWithRange.hxx Normal file
View File

@ -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_

101
src/RWStepKinematics/RWStepKinematics_RWProductDefinitionKinematics.cxx Normal file
View File

@ -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());
}

46
src/RWStepKinematics/RWStepKinematics_RWProductDefinitionKinematics.hxx Normal file
View File

@ -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_

101
src/RWStepKinematics/RWStepKinematics_RWProductDefinitionRelationshipKinematics.cxx Normal file
View File

@ -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());
}

46
src/RWStepKinematics/RWStepKinematics_RWProductDefinitionRelationshipKinematics.hxx Normal file
View File

@ -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_

150
src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPair.cxx Normal file
View File

@ -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
}

46
src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPair.hxx Normal file
View File

@ -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_

103
src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPairValue.cxx Normal file
View File

@ -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
}

46
src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPairValue.hxx Normal file
View File

@ -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_

190
src/RWStepKinematics/RWStepKinematics_RWRackAndPinionPairWithRange.cxx Normal file
View File

@ -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
}

Some files were not shown because too many files have changed in this diff Show More