n RWHeaderSection
n RWStepAP203
n RWStepAP214
+n RWStepAP242
n RWStepBasic
n RWStepDimTol
n RWStepElement
n StepAP203
n StepAP209
n StepAP214
+n StepAP242
n StepBasic
n StepData
n StepDimTol
#include <RWStepDimTol_RWCoaxialityTolerance.hxx>
#include <RWStepDimTol_RWCommonDatum.hxx>
#include <RWStepDimTol_RWConcentricityTolerance.hxx>
+#include <RWStepDimTol_RWCylindricityTolerance.hxx>
#include <RWStepDimTol_RWDatum.hxx>
#include <RWStepDimTol_RWDatumFeature.hxx>
#include <RWStepDimTol_RWDatumReference.hxx>
#include <StepDimTol_CoaxialityTolerance.hxx>
#include <StepDimTol_CommonDatum.hxx>
#include <StepDimTol_ConcentricityTolerance.hxx>
+#include <StepDimTol_CylindricityTolerance.hxx>
#include <StepDimTol_Datum.hxx>
#include <StepDimTol_DatumFeature.hxx>
#include <StepDimTol_DatumReference.hxx>
// ptv 28.01.2003
// TR12J 04.06.2003 G&DT entities GKA
// added by skl 10.02.2004 for TRJ13
+#include <StepBasic_ConversionBasedUnitAndMassUnit.hxx>
+#include <RWStepBasic_RWConversionBasedUnitAndMassUnit.hxx>
+#include <StepBasic_MassMeasureWithUnit.hxx>
+#include <RWStepBasic_RWMassMeasureWithUnit.hxx>
+
+// Added by ika for GD&T AP242
+#include <RWStepRepr_RWApex.hxx>
+#include <RWStepRepr_RWCentreOfSymmetry.hxx>
+#include <RWStepRepr_RWGeometricAlignment.hxx>
+#include <RWStepRepr_RWParallelOffset.hxx>
+#include <RWStepRepr_RWPerpendicularTo.hxx>
+#include <RWStepRepr_RWTangent.hxx>
+#include <RWStepAP242_RWGeometricItemSpecificUsage.hxx>
+#include <RWStepAP242_RWIdAttribute.hxx>
+#include <RWStepAP242_RWItemIdentifiedRepresentationUsage.hxx>
+#include <RWStepRepr_RWAllAroundShapeAspect.hxx>
+#include <RWStepRepr_RWBetweenShapeAspect.hxx>
+#include <RWStepRepr_RWCompositeGroupShapeAspect.hxx>
+#include <RWStepRepr_RWContinuosShapeAspect.hxx>
+#include <RWStepDimTol_RWGeometricToleranceWithDefinedAreaUnit.hxx>
+#include <RWStepDimTol_RWGeometricToleranceWithDefinedUnit.hxx>
+#include <RWStepDimTol_RWGeometricToleranceWithMaximumTolerance.hxx>
+#include <RWStepDimTol_RWGeometricToleranceWithModifiers.hxx>
+#include <RWStepDimTol_RWUnequallyDisposedGeometricTolerance.hxx>
+#include <RWStepDimTol_RWNonUniformZoneDefinition.hxx>
+#include <RWStepDimTol_RWProjectedZoneDefinition.hxx>
+#include <RWStepDimTol_RWRunoutZoneDefinition.hxx>
+#include <RWStepDimTol_RWRunoutZoneOrientation.hxx>
+#include <RWStepDimTol_RWToleranceZone.hxx>
+#include <RWStepDimTol_RWToleranceZoneDefinition.hxx>
+#include <RWStepDimTol_RWToleranceZoneForm.hxx>
+#include <RWStepShape_RWValueFormatTypeQualifier.hxx>
+#include <RWStepDimTol_RWDatumReferenceCompartment.hxx>
+#include <RWStepDimTol_RWDatumReferenceElement.hxx>
+#include <RWStepDimTol_RWDatumReferenceModifierWithValue.hxx>
+#include <RWStepDimTol_RWDatumSystem.hxx>
+#include <RWStepDimTol_RWGeneralDatumReference.hxx>
+#include <RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnit.hxx>
+#include <RWStepRepr_RWReprItemAndLengthMeasureWithUnitAndQRI.hxx>
+#include <RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnitAndQRI.hxx>
+#include <RWStepDimTol_RWGeoTolAndGeoTolWthDatRef.hxx>
+#include <RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMod.hxx>
+#include <RWStepDimTol_RWGeoTolAndGeoTolWthMod.hxx>
+#include <RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndUneqDisGeoTol.hxx>
+#include <RWStepRepr_RWCompGroupShAspAndCompShAspAndDatumFeatAndShAsp.hxx>
+#include <RWStepRepr_RWCompShAspAndDatumFeatAndShAsp.hxx>
+#include <RWStepRepr_RWIntegerRepresentationItem.hxx>
+#include <RWStepRepr_RWValueRepresentationItem.hxx>
+
+#include <StepRepr_Apex.hxx>
+#include <StepRepr_CentreOfSymmetry.hxx>
+#include <StepRepr_GeometricAlignment.hxx>
+#include <StepRepr_ParallelOffset.hxx>
+#include <StepRepr_PerpendicularTo.hxx>
+#include <StepRepr_Tangent.hxx>
+#include <StepAP242_GeometricItemSpecificUsage.hxx>
+#include <StepAP242_IdAttribute.hxx>
+#include <StepAP242_ItemIdentifiedRepresentationUsage.hxx>
+#include <StepRepr_AllAroundShapeAspect.hxx>
+#include <StepRepr_BetweenShapeAspect.hxx>
+#include <StepRepr_CompositeGroupShapeAspect.hxx>
+#include <StepRepr_ContinuosShapeAspect.hxx>
+#include <StepDimTol_GeometricToleranceWithDefinedAreaUnit.hxx>
+#include <StepDimTol_GeometricToleranceWithDefinedUnit.hxx>
+#include <StepDimTol_GeometricToleranceWithMaximumTolerance.hxx>
+#include <StepDimTol_GeometricToleranceWithModifiers.hxx>
+#include <StepDimTol_UnequallyDisposedGeometricTolerance.hxx>
+#include <StepDimTol_NonUniformZoneDefinition.hxx>
+#include <StepDimTol_ProjectedZoneDefinition.hxx>
+#include <StepDimTol_RunoutZoneDefinition.hxx>
+#include <StepDimTol_RunoutZoneOrientation.hxx>
+#include <StepDimTol_ToleranceZone.hxx>
+#include <StepDimTol_ToleranceZoneDefinition.hxx>
+#include <StepDimTol_ToleranceZoneForm.hxx>
+#include <StepShape_ValueFormatTypeQualifier.hxx>
+#include <StepDimTol_DatumReferenceCompartment.hxx>
+#include <StepDimTol_DatumReferenceElement.hxx>
+#include <StepDimTol_DatumReferenceModifierWithValue.hxx>
+#include <StepDimTol_DatumSystem.hxx>
+#include <StepDimTol_GeneralDatumReference.hxx>
+#include <StepRepr_ReprItemAndPlaneAngleMeasureWithUnit.hxx>
+#include <StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI.hxx>
+#include <StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI.hxx>
+#include <StepDimTol_GeoTolAndGeoTolWthDatRef.hxx>
+#include <StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod.hxx>
+#include <StepDimTol_GeoTolAndGeoTolWthMod.hxx>
+#include <StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol.hxx>
+#include <StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp.hxx>
+#include <StepRepr_CompShAspAndDatumFeatAndShAsp.hxx>
+#include <StepRepr_IntegerRepresentationItem.hxx>
+#include <StepRepr_ValueRepresentationItem.hxx>
+
static Standard_Integer catsh,catdr,catstr,catdsc,cataux;
break;
// TR12J 04.06.2003 G&DT entities GKA
+ case 609:
+ {
+ DeclareAndCast(StepDimTol_CylindricityTolerance,anent,ent);
+ RWStepDimTol_RWCylindricityTolerance tool;
+ tool.Share(anent,iter);
+ }
+ break;
case 610:
{
DeclareAndCast(StepShape_ShapeRepresentationWithParameters,anent,ent);
tool.Share(anent,iter);
}
break;
-
-
+ case 660:
+ {
+ DeclareAndCast(StepRepr_Apex,anent,ent);
+ RWStepRepr_RWApex tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 661:
+ {
+ DeclareAndCast(StepRepr_CentreOfSymmetry,anent,ent);
+ RWStepRepr_RWCentreOfSymmetry tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 662:
+ {
+ DeclareAndCast(StepRepr_GeometricAlignment,anent,ent);
+ RWStepRepr_RWGeometricAlignment tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 663:
+ {
+ DeclareAndCast(StepRepr_PerpendicularTo,anent,ent);
+ RWStepRepr_RWPerpendicularTo tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 664:
+ {
+ DeclareAndCast(StepRepr_Tangent,anent,ent);
+ RWStepRepr_RWTangent tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 665:
+ {
+ DeclareAndCast(StepRepr_ParallelOffset,anent,ent);
+ RWStepRepr_RWParallelOffset tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 666:
+ {
+ DeclareAndCast(StepAP242_GeometricItemSpecificUsage,anent,ent);
+ RWStepAP242_RWGeometricItemSpecificUsage tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 667:
+ {
+ DeclareAndCast(StepAP242_IdAttribute,anent,ent);
+ RWStepAP242_RWIdAttribute tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 668:
+ {
+ DeclareAndCast(StepAP242_ItemIdentifiedRepresentationUsage,anent,ent);
+ RWStepAP242_RWItemIdentifiedRepresentationUsage tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 669:
+ {
+ DeclareAndCast(StepRepr_AllAroundShapeAspect,anent,ent);
+ RWStepRepr_RWAllAroundShapeAspect tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 670:
+ {
+ DeclareAndCast(StepRepr_BetweenShapeAspect,anent,ent);
+ RWStepRepr_RWBetweenShapeAspect tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 671:
+ {
+ DeclareAndCast(StepRepr_CompositeGroupShapeAspect,anent,ent);
+ RWStepRepr_RWCompositeGroupShapeAspect tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 672:
+ {
+ DeclareAndCast(StepRepr_ContinuosShapeAspect,anent,ent);
+ RWStepRepr_RWContinuosShapeAspect tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 673:
+ {
+ DeclareAndCast(StepDimTol_GeometricToleranceWithDefinedAreaUnit,anent,ent);
+ RWStepDimTol_RWGeometricToleranceWithDefinedAreaUnit tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 674:
+ {
+ DeclareAndCast(StepDimTol_GeometricToleranceWithDefinedUnit,anent,ent);
+ RWStepDimTol_RWGeometricToleranceWithDefinedUnit tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 675:
+ {
+ DeclareAndCast(StepDimTol_GeometricToleranceWithMaximumTolerance,anent,ent);
+ RWStepDimTol_RWGeometricToleranceWithMaximumTolerance tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 676:
+ {
+ DeclareAndCast(StepDimTol_GeometricToleranceWithModifiers,anent,ent);
+ RWStepDimTol_RWGeometricToleranceWithModifiers tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 677:
+ {
+ DeclareAndCast(StepDimTol_UnequallyDisposedGeometricTolerance,anent,ent);
+ RWStepDimTol_RWUnequallyDisposedGeometricTolerance tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 678:
+ {
+ DeclareAndCast(StepDimTol_NonUniformZoneDefinition,anent,ent);
+ RWStepDimTol_RWNonUniformZoneDefinition tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 679:
+ {
+ DeclareAndCast(StepDimTol_ProjectedZoneDefinition,anent,ent);
+ RWStepDimTol_RWProjectedZoneDefinition tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 680:
+ {
+ DeclareAndCast(StepDimTol_RunoutZoneDefinition,anent,ent);
+ RWStepDimTol_RWRunoutZoneDefinition tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ //case 681: no shared attributes
+ case 682:
+ {
+ DeclareAndCast(StepDimTol_ToleranceZone,anent,ent);
+ RWStepDimTol_RWToleranceZone tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 683:
+ {
+ DeclareAndCast(StepDimTol_ToleranceZoneDefinition,anent,ent);
+ RWStepDimTol_RWToleranceZoneDefinition tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ //case 684: no shared attributes
+ //case 685: no shared attributes
+ case 686 :
+ {
+ DeclareAndCast(StepDimTol_DatumReferenceCompartment, anent, ent);
+ RWStepDimTol_RWDatumReferenceCompartment tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 687 :
+ {
+ DeclareAndCast(StepDimTol_DatumReferenceElement, anent, ent);
+ RWStepDimTol_RWDatumReferenceElement tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ //case 688: no shared attributes
+ case 689 :
+ {
+ DeclareAndCast(StepDimTol_DatumSystem, anent, ent);
+ RWStepDimTol_RWDatumSystem tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 690 :
+ {
+ DeclareAndCast(StepDimTol_GeneralDatumReference, anent, ent);
+ RWStepDimTol_RWGeneralDatumReference tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 694:
+ {
+ DeclareAndCast(StepDimTol_GeoTolAndGeoTolWthDatRef,anent,ent);
+ RWStepDimTol_RWGeoTolAndGeoTolWthDatRef tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 695:
+ {
+ DeclareAndCast(StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod,anent,ent);
+ RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMod tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 696:
+ {
+ DeclareAndCast(StepDimTol_GeoTolAndGeoTolWthMod,anent,ent);
+ RWStepDimTol_RWGeoTolAndGeoTolWthMod tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 697:
+ {
+ DeclareAndCast(StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol,anent,ent);
+ RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndUneqDisGeoTol tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 698:
+ {
+ DeclareAndCast(StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp,anent,ent);
+ RWStepRepr_RWCompGroupShAspAndCompShAspAndDatumFeatAndShAsp tool;
+ tool.Share(anent,iter);
+ }
+ break;
+ case 699:
+ {
+ DeclareAndCast(StepRepr_CompShAspAndDatumFeatAndShAsp,anent,ent);
+ RWStepRepr_RWCompShAspAndDatumFeatAndShAsp tool;
+ tool.Share(anent,iter);
+ }
+ break;
+
default : break;
}
}
case 601:
ent = new StepBasic_DocumentProductEquivalence;
break;
-
+ case 609:
+ ent = new StepDimTol_CylindricityTolerance;
+ break;
case 610:
ent = new StepShape_ShapeRepresentationWithParameters;
break;
case 651 :
ent = new StepBasic_MassMeasureWithUnit;
break;
-
-
+ case 660 :
+ ent = new StepRepr_Apex;
+ break;
+ case 661 :
+ ent = new StepRepr_CentreOfSymmetry;
+ break;
+ case 662 :
+ ent = new StepRepr_GeometricAlignment;
+ break;
+ case 663 :
+ ent = new StepRepr_PerpendicularTo;
+ break;
+ case 664 :
+ ent = new StepRepr_Tangent;
+ break;
+ case 665 :
+ ent = new StepRepr_ParallelOffset;
+ break;
+ case 666 :
+ ent = new StepAP242_GeometricItemSpecificUsage;
+ break;
+ case 667 :
+ ent = new StepAP242_IdAttribute;
+ break;
+ case 668 :
+ ent = new StepAP242_ItemIdentifiedRepresentationUsage;
+ break;
+ case 669 :
+ ent = new StepRepr_AllAroundShapeAspect;
+ break;
+ case 670 :
+ ent = new StepRepr_BetweenShapeAspect;
+ break;
+ case 671 :
+ ent = new StepRepr_CompositeGroupShapeAspect;
+ break;
+ case 672 :
+ ent = new StepRepr_ContinuosShapeAspect;
+ break;
+ case 673 :
+ ent = new StepDimTol_GeometricToleranceWithDefinedAreaUnit;
+ break;
+ case 674 :
+ ent = new StepDimTol_GeometricToleranceWithDefinedUnit;
+ break;
+ case 675 :
+ ent = new StepDimTol_GeometricToleranceWithMaximumTolerance;
+ break;
+ case 676 :
+ ent = new StepDimTol_GeometricToleranceWithModifiers;
+ break;
+ case 677 :
+ ent = new StepDimTol_UnequallyDisposedGeometricTolerance;
+ break;
+ case 678 :
+ ent = new StepDimTol_NonUniformZoneDefinition;
+ break;
+ case 679 :
+ ent = new StepDimTol_ProjectedZoneDefinition;
+ break;
+ case 680 :
+ ent = new StepDimTol_RunoutZoneDefinition;
+ break;
+ case 681 :
+ ent = new StepDimTol_RunoutZoneOrientation;
+ break;
+ case 682 :
+ ent = new StepDimTol_ToleranceZone;
+ break;
+ case 683 :
+ ent = new StepDimTol_ToleranceZoneDefinition;
+ break;
+ case 684 :
+ ent = new StepDimTol_ToleranceZoneForm;
+ break;
+ case 685 :
+ ent = new StepShape_ValueFormatTypeQualifier;
+ break;
+ case 686 :
+ ent = new StepDimTol_DatumReferenceCompartment;
+ break;
+ case 687 :
+ ent = new StepDimTol_DatumReferenceElement;
+ break;
+ case 688 :
+ ent = new StepDimTol_DatumReferenceModifierWithValue;
+ break;
+ case 689 :
+ ent = new StepDimTol_DatumSystem;
+ break;
+ case 690 :
+ ent = new StepDimTol_GeneralDatumReference;
+ break;
+ case 691 :
+ ent = new StepRepr_ReprItemAndPlaneAngleMeasureWithUnit;
+ break;
+ case 692 :
+ ent = new StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI;
+ break;
+ case 693 :
+ ent = new StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI;
+ break;
+ case 694 :
+ ent = new StepDimTol_GeoTolAndGeoTolWthDatRef;
+ break;
+ case 695 :
+ ent = new StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod;
+ break;
+ case 696 :
+ ent = new StepDimTol_GeoTolAndGeoTolWthMod;
+ break;
+ case 697 :
+ ent = new StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol;
+ break;
+ case 698 :
+ ent = new StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp;
+ break;
+ case 699 :
+ ent = new StepRepr_CompShAspAndDatumFeatAndShAsp;
+ break;
+ case 700:
+ ent = new StepRepr_IntegerRepresentationItem;
+ break;
+ case 701:
+ ent = new StepRepr_ValueRepresentationItem;
+ break;
+
default:
return Standard_False;
}
case 496: return catsh;
case 600:
case 601: return cataux;
+ case 609:
case 610:
case 611:
case 612:
case 636: return cataux;
case 650:
case 651: return cataux;
+ case 660:
+ case 661:
+ case 662:
+ case 663:
+ case 664:
+ case 665:
+ case 666:
+ case 667:
+ case 668:
+ case 669:
+ case 670:
+ case 671:
+ case 672: return catdr;
+ case 673:
+ case 674:
+ case 675:
+ case 676:
+ case 677:
+ case 678:
+ case 679:
+ case 680:
+ case 681:
+ case 682:
+ case 683:
+ case 684: return cataux;
+ case 685: return catdr;
+ case 686:
+ case 687:
+ case 688:
+ case 689:
+ case 690:
+ case 691:
+ case 692:
+ case 693:
+ case 694:
+ case 695:
+ case 696:
+ case 697: return cataux;
+ case 698:
+ case 699:
+ case 700:
+ case 701: return catdr;
default : break;
}
#include <StepDimTol_ConcentricityTolerance.hxx>
#include <StepDimTol_CircularRunoutTolerance.hxx>
#include <StepDimTol_CoaxialityTolerance.hxx>
+#include <StepDimTol_CylindricityTolerance.hxx>
#include <StepDimTol_FlatnessTolerance.hxx>
#include <StepDimTol_LineProfileTolerance.hxx>
#include <StepDimTol_ParallelismTolerance.hxx>
#include <RWStepDimTol_RWConcentricityTolerance.hxx>
#include <RWStepDimTol_RWCircularRunoutTolerance.hxx>
#include <RWStepDimTol_RWCoaxialityTolerance.hxx>
+#include <RWStepDimTol_RWCylindricityTolerance.hxx>
#include <RWStepDimTol_RWFlatnessTolerance.hxx>
#include <RWStepDimTol_RWLineProfileTolerance.hxx>
#include <RWStepDimTol_RWParallelismTolerance.hxx>
#include <StepBasic_MassMeasureWithUnit.hxx>
#include <RWStepBasic_RWMassMeasureWithUnit.hxx>
+// Added by ika for GD&T AP242
+#include <RWStepRepr_RWApex.hxx>
+#include <RWStepRepr_RWCentreOfSymmetry.hxx>
+#include <RWStepRepr_RWGeometricAlignment.hxx>
+#include <RWStepRepr_RWParallelOffset.hxx>
+#include <RWStepRepr_RWPerpendicularTo.hxx>
+#include <RWStepRepr_RWTangent.hxx>
+#include <RWStepAP242_RWGeometricItemSpecificUsage.hxx>
+#include <RWStepAP242_RWIdAttribute.hxx>
+#include <RWStepAP242_RWItemIdentifiedRepresentationUsage.hxx>
+#include <RWStepRepr_RWAllAroundShapeAspect.hxx>
+#include <RWStepRepr_RWBetweenShapeAspect.hxx>
+#include <RWStepRepr_RWCompositeGroupShapeAspect.hxx>
+#include <RWStepRepr_RWContinuosShapeAspect.hxx>
+#include <RWStepDimTol_RWGeometricToleranceWithDefinedAreaUnit.hxx>
+#include <RWStepDimTol_RWGeometricToleranceWithDefinedUnit.hxx>
+#include <RWStepDimTol_RWGeometricToleranceWithMaximumTolerance.hxx>
+#include <RWStepDimTol_RWGeometricToleranceWithModifiers.hxx>
+#include <RWStepDimTol_RWUnequallyDisposedGeometricTolerance.hxx>
+#include <RWStepDimTol_RWNonUniformZoneDefinition.hxx>
+#include <RWStepDimTol_RWProjectedZoneDefinition.hxx>
+#include <RWStepDimTol_RWRunoutZoneDefinition.hxx>
+#include <RWStepDimTol_RWRunoutZoneOrientation.hxx>
+#include <RWStepDimTol_RWToleranceZone.hxx>
+#include <RWStepDimTol_RWToleranceZoneDefinition.hxx>
+#include <RWStepDimTol_RWToleranceZoneForm.hxx>
+#include <RWStepShape_RWValueFormatTypeQualifier.hxx>
+#include <RWStepDimTol_RWDatumReferenceCompartment.hxx>
+#include <RWStepDimTol_RWDatumReferenceElement.hxx>
+#include <RWStepDimTol_RWDatumReferenceModifierWithValue.hxx>
+#include <RWStepDimTol_RWDatumSystem.hxx>
+#include <RWStepDimTol_RWGeneralDatumReference.hxx>
+#include <RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnit.hxx>
+#include <RWStepRepr_RWReprItemAndLengthMeasureWithUnitAndQRI.hxx>
+#include <RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnitAndQRI.hxx>
+#include <RWStepDimTol_RWGeoTolAndGeoTolWthDatRef.hxx>
+#include <RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMod.hxx>
+#include <RWStepDimTol_RWGeoTolAndGeoTolWthMod.hxx>
+#include <RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndUneqDisGeoTol.hxx>
+#include <RWStepRepr_RWCompGroupShAspAndCompShAspAndDatumFeatAndShAsp.hxx>
+#include <RWStepRepr_RWCompShAspAndDatumFeatAndShAsp.hxx>
+#include <RWStepRepr_RWIntegerRepresentationItem.hxx>
+#include <RWStepRepr_RWValueRepresentationItem.hxx>
+
+#include <StepRepr_Apex.hxx>
+#include <StepRepr_CentreOfSymmetry.hxx>
+#include <StepRepr_GeometricAlignment.hxx>
+#include <StepRepr_ParallelOffset.hxx>
+#include <StepRepr_PerpendicularTo.hxx>
+#include <StepRepr_Tangent.hxx>
+#include <StepAP242_GeometricItemSpecificUsage.hxx>
+#include <StepAP242_IdAttribute.hxx>
+#include <StepAP242_ItemIdentifiedRepresentationUsage.hxx>
+#include <StepRepr_AllAroundShapeAspect.hxx>
+#include <StepRepr_BetweenShapeAspect.hxx>
+#include <StepRepr_CompositeGroupShapeAspect.hxx>
+#include <StepRepr_ContinuosShapeAspect.hxx>
+#include <StepDimTol_GeometricToleranceWithDefinedAreaUnit.hxx>
+#include <StepDimTol_GeometricToleranceWithDefinedUnit.hxx>
+#include <StepDimTol_GeometricToleranceWithMaximumTolerance.hxx>
+#include <StepDimTol_GeometricToleranceWithModifiers.hxx>
+#include <StepDimTol_UnequallyDisposedGeometricTolerance.hxx>
+#include <StepDimTol_NonUniformZoneDefinition.hxx>
+#include <StepDimTol_ProjectedZoneDefinition.hxx>
+#include <StepDimTol_RunoutZoneDefinition.hxx>
+#include <StepDimTol_RunoutZoneOrientation.hxx>
+#include <StepDimTol_ToleranceZone.hxx>
+#include <StepDimTol_ToleranceZoneDefinition.hxx>
+#include <StepDimTol_ToleranceZoneForm.hxx>
+#include <StepShape_ValueFormatTypeQualifier.hxx>
+#include <StepDimTol_DatumReferenceCompartment.hxx>
+#include <StepDimTol_DatumReferenceElement.hxx>
+#include <StepDimTol_DatumReferenceModifierWithValue.hxx>
+#include <StepDimTol_DatumSystem.hxx>
+#include <StepDimTol_GeneralDatumReference.hxx>
+#include <StepRepr_ReprItemAndPlaneAngleMeasureWithUnit.hxx>
+#include <StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI.hxx>
+#include <StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI.hxx>
+#include <StepDimTol_GeoTolAndGeoTolWthDatRef.hxx>
+#include <StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod.hxx>
+#include <StepDimTol_GeoTolAndGeoTolWthMod.hxx>
+#include <StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol.hxx>
+#include <StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp.hxx>
+#include <StepRepr_CompShAspAndDatumFeatAndShAsp.hxx>
+#include <StepRepr_IntegerRepresentationItem.hxx>
+#include <StepRepr_ValueRepresentationItem.hxx>
+
// -- General Declarations (Recognize, StepType) ---
static TCollection_AsciiString Reco_ConcentricityTolerance("CONCENTRICITY_TOLERANCE");
static TCollection_AsciiString Reco_CircularRunoutTolerance("CIRCULAR_RUNOUT_TOLERANCE");
static TCollection_AsciiString Reco_CoaxialityTolerance("COAXIALITY_TOLERANCE");
+static TCollection_AsciiString Reco_CylindricityTolerance("CYLINDRICITY_TOLERANCE");
static TCollection_AsciiString Reco_FlatnessTolerance("FLATNESS_TOLERANCE");
static TCollection_AsciiString Reco_LineProfileTolerance("LINE_PROFILE_TOLERANCE");
static TCollection_AsciiString Reco_ParallelismTolerance("PARALLELISM_TOLERANCE");
static TCollection_AsciiString Reco_DatumTarget("DATUM_TARGET");
static TCollection_AsciiString Reco_PlacedDatumTargetFeature("PLACED_DATUM_TARGET_FEATURE");
+//Added by ika for GD&T AP242
+static TCollection_AsciiString Reco_Apex("APEX");
+static TCollection_AsciiString Reco_CentreOfSymmetry("CENTRE_OF_SYMMETRY");
+static TCollection_AsciiString Reco_GeometricAlignment("GEOMETRIC_ALIGNMENT");
+static TCollection_AsciiString Reco_PerpendicularTo("PERPENDICULAR_TO");
+static TCollection_AsciiString Reco_Tangent("TANGENT");
+static TCollection_AsciiString Reco_ParallelOffset("PARALLEL_OFFSET");
+static TCollection_AsciiString Reco_GeometricItemSpecificUsage("GEOMETRIC_ITEM_SPECIFIC_USAGE");
+static TCollection_AsciiString Reco_IdAttribute("ID_ATTRIBUTE");
+static TCollection_AsciiString Reco_ItemIdentifiedRepresentationUsage("ITEM_IDENTIFIED_REPRESENTATION_USAGE");
+static TCollection_AsciiString Reco_AllAroundShapeAspect("ALL_AROUND_SHAPE_ASPECT");
+static TCollection_AsciiString Reco_BetweenShapeAspect("BETWEEN_SHAPE_ASPECT");
+static TCollection_AsciiString Reco_CompositeGroupShapeAspect("COMPOSITE_GROUP_SHAPE_ASPECT");
+static TCollection_AsciiString Reco_ContinuosShapeAspect("CONTINUOUS_SHAPE_ASPECT");
+static TCollection_AsciiString Reco_GeometricToleranceWithDefinedAreaUnit("GEOMETRIC_TOLERANCE_WITH_DEFINED_AREA_UNIT");
+static TCollection_AsciiString Reco_GeometricToleranceWithDefinedUnit("GEOMETRIC_TOLERANCE_WITH_DEFINED_UNIT");
+static TCollection_AsciiString Reco_GeometricToleranceWithMaximumTolerance("GEOMETRIC_TOLERANCE_WITH_MAXIMUM_TOLERANCE");
+static TCollection_AsciiString Reco_GeometricToleranceWithModifiers("GEOMETRIC_TOLERANCE_WITH_MODIFIERS");
+static TCollection_AsciiString Reco_UnequallyDisposedGeometricTolerance("UNEQUALLY_DISPOSED_GEOMETRIC_TOLERANCE");
+static TCollection_AsciiString Reco_NonUniformZoneDefinition("NON_UNIFORM_ZONE_DEFINITION");
+static TCollection_AsciiString Reco_ProjectedZoneDefinition("PROJECTED_ZONE_DEFINITION");
+static TCollection_AsciiString Reco_RunoutZoneDefinition("RUNOUT_ZONE_DEFINITION");
+static TCollection_AsciiString Reco_RunoutZoneOrientation("RUNOUT_ZONE_ORIENTATION");
+static TCollection_AsciiString Reco_ToleranceZone("TOLERANCE_ZONE");
+static TCollection_AsciiString Reco_ToleranceZoneDefinition("TOLERANCE_ZONE_DEFINITION");
+static TCollection_AsciiString Reco_ToleranceZoneForm("TOLERANCE_ZONE_FORM");
+static TCollection_AsciiString Reco_ValueFormatTypeQualifier("VALUE_FORMAT_TYPE_QUALIFIER");
+static TCollection_AsciiString Reco_DatumReferenceCompartment("DATUM_REFERENCE_COMPARTMENT");
+static TCollection_AsciiString Reco_DatumReferenceElement("DATUM_REFERENCE_ELEMENT");
+static TCollection_AsciiString Reco_DatumReferenceModifierWithValue("DATUM_REFERENCE_MODIFIER_WITH_VALUE");
+static TCollection_AsciiString Reco_DatumSystem("DATUM_SYSTEM");
+static TCollection_AsciiString Reco_GeneralDatumReference("GENERAL_DATUM_REFERENCE");
+static TCollection_AsciiString Reco_IntegerRepresentationItem("INTEGER_REPRESENTATION_ITEM");
+static TCollection_AsciiString Reco_ValueRepresentationItem("VALUE_REPRESENTATION_ITEM");
// -- Definition of the libraries --
typenums->SetItem (Reco_DocumentProductEquivalence,601);
// Added by SKL 18.06.2003 for Dimensional Tolerances (CAX-IF TRJ11)
+ typenums->SetItem (Reco_CylindricityTolerance,609);
typenums->SetItem (Reco_ShapeRepresentationWithParameters,610);
typenums->SetItem (Reco_AngularityTolerance,611);
typenums->SetItem (Reco_ConcentricityTolerance,612);
typenums->SetItem (Reco_MassMeasureWithUnit,651);
+ //Added by ika for GD&T AP242
+ typenums->SetItem (Reco_Apex, 660);
+ typenums->SetItem (Reco_CentreOfSymmetry, 661);
+ typenums->SetItem (Reco_GeometricAlignment, 662);
+ typenums->SetItem (Reco_PerpendicularTo, 663);
+ typenums->SetItem (Reco_Tangent, 664);
+ typenums->SetItem (Reco_ParallelOffset, 665);
+ typenums->SetItem (Reco_GeometricItemSpecificUsage, 666);
+ typenums->SetItem (Reco_IdAttribute, 667);
+ typenums->SetItem (Reco_ItemIdentifiedRepresentationUsage, 668);
+ typenums->SetItem (Reco_AllAroundShapeAspect, 669);
+ typenums->SetItem (Reco_BetweenShapeAspect, 670);
+ typenums->SetItem (Reco_CompositeGroupShapeAspect, 671);
+ typenums->SetItem (Reco_ContinuosShapeAspect, 672);
+ typenums->SetItem (Reco_GeometricToleranceWithDefinedAreaUnit, 673);
+ typenums->SetItem (Reco_GeometricToleranceWithDefinedUnit, 674);
+ typenums->SetItem (Reco_GeometricToleranceWithMaximumTolerance, 675);
+ typenums->SetItem (Reco_GeometricToleranceWithModifiers, 676);
+ typenums->SetItem (Reco_UnequallyDisposedGeometricTolerance, 677);
+ typenums->SetItem (Reco_NonUniformZoneDefinition, 678);
+ typenums->SetItem (Reco_ProjectedZoneDefinition, 679);
+ typenums->SetItem (Reco_RunoutZoneDefinition, 680);
+ typenums->SetItem (Reco_RunoutZoneOrientation, 681);
+ typenums->SetItem (Reco_ToleranceZone, 682);
+ typenums->SetItem (Reco_ToleranceZoneDefinition, 683);
+ typenums->SetItem (Reco_ToleranceZoneForm, 684);
+ typenums->SetItem (Reco_ValueFormatTypeQualifier, 685);
+ typenums->SetItem (Reco_DatumReferenceCompartment, 686);
+ typenums->SetItem (Reco_DatumReferenceElement, 687);
+ typenums->SetItem (Reco_DatumReferenceModifierWithValue, 688);
+ typenums->SetItem (Reco_DatumSystem, 689);
+ typenums->SetItem (Reco_GeneralDatumReference, 690);
+ typenums->SetItem (Reco_IntegerRepresentationItem, 700);
+ typenums->SetItem (Reco_ValueRepresentationItem, 701);
+
// SHORT NAMES
// NB : la liste est celle de AP203
// Directement exploite pour les types simples
if (NbComp == 7) {
if ((types(1).IsEqual(StepType(48))) &&
- (types(2).IsEqual(StepType(38))) &&
- (types(3).IsEqual(StepType(84))) &&
- (types(4).IsEqual(StepType(144))) &&
- (types(5).IsEqual(StepType(239))) &&
- (types(6).IsEqual(StepType(247))) &&
- (types(7).IsEqual(StepType(311)))) {
- return 319;
+ (types(2).IsEqual(StepType(38))) &&
+ (types(3).IsEqual(StepType(84))) &&
+ (types(4).IsEqual(StepType(144))) &&
+ (types(5).IsEqual(StepType(239))) &&
+ (types(6).IsEqual(StepType(247))) &&
+ (types(7).IsEqual(StepType(311)))) {
+ return 319;
}
else if ((types(1).IsEqual(StepType(48))) &&
- (types(2).IsEqual(StepType(38))) &&
- (types(3).IsEqual(StepType(39))) &&
- (types(4).IsEqual(StepType(84))) &&
- (types(5).IsEqual(StepType(144))) &&
- (types(6).IsEqual(StepType(239))) &&
- (types(7).IsEqual(StepType(247)))) {
- return 320;
+ (types(2).IsEqual(StepType(38))) &&
+ (types(3).IsEqual(StepType(39))) &&
+ (types(4).IsEqual(StepType(84))) &&
+ (types(5).IsEqual(StepType(144))) &&
+ (types(6).IsEqual(StepType(239))) &&
+ (types(7).IsEqual(StepType(247)))) {
+ return 320;
}
else if ((types(1).IsEqual(StepType(48))) &&
- (types(2).IsEqual(StepType(38))) &&
- (types(3).IsEqual(StepType(84))) &&
- (types(4).IsEqual(StepType(144))) &&
- (types(5).IsEqual(StepType(236))) &&
- (types(6).IsEqual(StepType(239))) &&
- (types(7).IsEqual(StepType(247)))) {
- return 321;
+ (types(2).IsEqual(StepType(38))) &&
+ (types(3).IsEqual(StepType(84))) &&
+ (types(4).IsEqual(StepType(144))) &&
+ (types(5).IsEqual(StepType(236))) &&
+ (types(6).IsEqual(StepType(239))) &&
+ (types(7).IsEqual(StepType(247)))) {
+ return 321;
}
else if ((types(1).IsEqual(StepType(43))) &&
- (types(2).IsEqual(StepType(48))) &&
- (types(3).IsEqual(StepType(38))) &&
- (types(4).IsEqual(StepType(84))) &&
- (types(5).IsEqual(StepType(144))) &&
- (types(6).IsEqual(StepType(239))) &&
- (types(7).IsEqual(StepType(247)))) {
- return 322;
+ (types(2).IsEqual(StepType(48))) &&
+ (types(3).IsEqual(StepType(38))) &&
+ (types(4).IsEqual(StepType(84))) &&
+ (types(5).IsEqual(StepType(144))) &&
+ (types(6).IsEqual(StepType(239))) &&
+ (types(7).IsEqual(StepType(247)))) {
+ return 322;
}
else if ((types(1).IsEqual(StepType(49))) &&
- (types(2).IsEqual(StepType(40))) &&
- (types(3).IsEqual(StepType(41))) &&
- (types(4).IsEqual(StepType(144))) &&
- (types(5).IsEqual(StepType(240))) &&
- (types(6).IsEqual(StepType(247))) &&
- (types(7).IsEqual(StepType(271)))) {
- return 323;
+ (types(2).IsEqual(StepType(40))) &&
+ (types(3).IsEqual(StepType(41))) &&
+ (types(4).IsEqual(StepType(144))) &&
+ (types(5).IsEqual(StepType(240))) &&
+ (types(6).IsEqual(StepType(247))) &&
+ (types(7).IsEqual(StepType(271)))) {
+ return 323;
}
else if ((types(1).IsEqual(StepType(49))) &&
- (types(2).IsEqual(StepType(40))) &&
- (types(3).IsEqual(StepType(144))) &&
- (types(4).IsEqual(StepType(240))) &&
- (types(5).IsEqual(StepType(247))) &&
- (types(6).IsEqual(StepType(271))) &&
- (types(7).IsEqual(StepType(312)))) {
- return 324;
+ (types(2).IsEqual(StepType(40))) &&
+ (types(3).IsEqual(StepType(144))) &&
+ (types(4).IsEqual(StepType(240))) &&
+ (types(5).IsEqual(StepType(247))) &&
+ (types(6).IsEqual(StepType(271))) &&
+ (types(7).IsEqual(StepType(312)))) {
+ return 324;
}
else if ((types(1).IsEqual(StepType(49))) &&
- (types(2).IsEqual(StepType(40))) &&
- (types(3).IsEqual(StepType(144))) &&
- (types(4).IsEqual(StepType(237))) &&
- (types(5).IsEqual(StepType(240))) &&
- (types(6).IsEqual(StepType(247))) &&
- (types(7).IsEqual(StepType(271)))) {
- return 325;
+ (types(2).IsEqual(StepType(40))) &&
+ (types(3).IsEqual(StepType(144))) &&
+ (types(4).IsEqual(StepType(237))) &&
+ (types(5).IsEqual(StepType(240))) &&
+ (types(6).IsEqual(StepType(247))) &&
+ (types(7).IsEqual(StepType(271)))) {
+ return 325;
}
else if ((types(1).IsEqual(StepType(44))) &&
- (types(2).IsEqual(StepType(49))) &&
- (types(3).IsEqual(StepType(40))) &&
- (types(4).IsEqual(StepType(144))) &&
- (types(5).IsEqual(StepType(240))) &&
- (types(6).IsEqual(StepType(247))) &&
- (types(7).IsEqual(StepType(271)))) {
- return 326;
+ (types(2).IsEqual(StepType(49))) &&
+ (types(3).IsEqual(StepType(40))) &&
+ (types(4).IsEqual(StepType(144))) &&
+ (types(5).IsEqual(StepType(240))) &&
+ (types(6).IsEqual(StepType(247))) &&
+ (types(7).IsEqual(StepType(271)))) {
+ return 326;
}
else if ((types(1).IsEqual(StepType(40))) &&
- (types(2).IsEqual(StepType(41))) &&
- (types(3).IsEqual(StepType(49))) &&
- (types(4).IsEqual(StepType(144))) &&
- (types(5).IsEqual(StepType(240))) &&
- (types(6).IsEqual(StepType(247))) &&
- (types(7).IsEqual(StepType(271)))) {
- return 323;
+ (types(2).IsEqual(StepType(41))) &&
+ (types(3).IsEqual(StepType(49))) &&
+ (types(4).IsEqual(StepType(144))) &&
+ (types(5).IsEqual(StepType(240))) &&
+ (types(6).IsEqual(StepType(247))) &&
+ (types(7).IsEqual(StepType(271)))) {
+ return 323;
+ }
+ }
+ // Added by FMA
+ else if (NbComp == 6) {
+ if (types(1).IsEqual(StepType(52)) &&
+ types(2).IsEqual(StepType(134)) &&
+ types(3).IsEqual(StepType(144)) &&
+ types(4).IsEqual(StepType(162)) &&
+ types(5).IsEqual(StepType(247)) &&
+ types(6).IsEqual(StepType(266))) {
+ return 337;
+ }
+ }
+ else if (NbComp == 5) {
+ //:n5 abv 15 Feb 99: S4132 complex type bounded_curve + surface_curve
+ if ((types(1).IsEqual(StepType(48))) &&
+ (types(2).IsEqual(StepType(84))) &&
+ (types(3).IsEqual(StepType(144))) &&
+ (types(4).IsEqual(StepType(247))) &&
+ (types(5).IsEqual(StepType(272)))) {
+ return 358;
+ }
+ else if ((types(1).IsEqual(StepType(157))) &&
+ (types(2).IsEqual(StepType(406))) &&
+ (types(3).IsEqual(StepType(165))) &&
+ (types(4).IsEqual(StepType(480))) &&
+ (types(5).IsEqual(StepType(247)))) {
+ return 692;
+ }
+ else if ((types(1).IsEqual(StepType(406))) &&
+ (types(2).IsEqual(StepType(165))) &&
+ (types(3).IsEqual(StepType(200))) &&
+ (types(4).IsEqual(StepType(480))) &&
+ (types(5).IsEqual(StepType(247)))) {
+ return 693;
+ }
+ }
+ else if (NbComp == 4) {
+ if ((types(1).IsEqual(StepType(161))) &&
+ (types(2).IsEqual(StepType(189))) &&
+ (types(3).IsEqual(StepType(247))) &&
+ (types(4).IsEqual(StepType(304)))) {
+ return 332;
+ }
+ // Added by FMA
+ else if ((types(1).IsEqual(StepType(143)) &&
+ types(2).IsEqual(StepType(148)) &&
+ types(3).IsEqual(StepType(149)) &&
+ types(4).IsEqual(StepType(246)))) {
+ return 333;
+ }
+
+ else if ((types(1).IsEqual(StepType(157))) &&
+ (types(2).IsEqual(StepType(406))) &&
+ (types(3).IsEqual(StepType(165))) &&
+ (types(4).IsEqual(StepType(247)))) {
+ return 635;
+ }
+ else if ((types(1).IsEqual(StepType(625))) &&
+ (types(2).IsEqual(StepType(627))) &&
+ (types(3).IsEqual(StepType(628))) &&
+ (types(4).IsEqual(StepType(619)))) {
+ return 636;
+ }
+ else if ((types(1).IsEqual(StepType(406))) &&
+ (types(2).IsEqual(StepType(165))) &&
+ (types(3).IsEqual(StepType(200))) &&
+ (types(4).IsEqual(StepType(247)))) {
+ return 691;
+ }
+ else if (((types(1).IsEqual(StepType(609)) ||
+ types(1).IsEqual(StepType(611)) ||
+ types(1).IsEqual(StepType(612)) ||
+ types(1).IsEqual(StepType(613)) ||
+ types(1).IsEqual(StepType(614)) ||
+ types(1).IsEqual(StepType(615))) &&
+ types(2).IsEqual(StepType(625)) &&
+ types(3).IsEqual(StepType(627)) &&
+ types(4).IsEqual(StepType(676)))
+ ||
+ (types(1).IsEqual(StepType(625)) &&
+ types(2).IsEqual(StepType(627)) &&
+ types(3).IsEqual(StepType(676)) &&
+ (types(4).IsEqual(StepType(616)) ||
+ types(4).IsEqual(StepType(617)) ||
+ types(4).IsEqual(StepType(618)) ||
+ types(4).IsEqual(StepType(619)) ||
+ types(4).IsEqual(StepType(620)) ||
+ types(4).IsEqual(StepType(621)) ||
+ types(4).IsEqual(StepType(622)) ||
+ types(4).IsEqual(StepType(623)) ||
+ types(4).IsEqual(StepType(624))))) {
+ return 695;
+ }
+ else if (((types(1).IsEqual(StepType(609)) ||
+ types(1).IsEqual(StepType(611)) ||
+ types(1).IsEqual(StepType(612)) ||
+ types(1).IsEqual(StepType(613)) ||
+ types(1).IsEqual(StepType(614)) ||
+ types(1).IsEqual(StepType(615))) &&
+ types(2).IsEqual(StepType(625)) &&
+ types(3).IsEqual(StepType(627)) &&
+ types(4).IsEqual(StepType(677)))
+ ||
+ (types(1).IsEqual(StepType(625)) &&
+ types(2).IsEqual(StepType(627)) &&
+ types(4).IsEqual(StepType(677)) &&
+ (types(3).IsEqual(StepType(616)) ||
+ types(3).IsEqual(StepType(617)) ||
+ types(3).IsEqual(StepType(618)) ||
+ types(3).IsEqual(StepType(619)) ||
+ types(3).IsEqual(StepType(620)) ||
+ types(3).IsEqual(StepType(621)) ||
+ types(3).IsEqual(StepType(622)) ||
+ types(3).IsEqual(StepType(623)) ||
+ types(3).IsEqual(StepType(624))))) {
+ return 697;
+ }
+ else if (types(1).IsEqual(StepType(671)) &&
+ types(2).IsEqual(StepType(470)) &&
+ types(3).IsEqual(StepType(630)) &&
+ types(4).IsEqual(StepType(258))) {
+ return 698;
}
}
- if (NbComp == 3) {
+ else if (NbComp == 3) {
if ((types(1).IsEqual(StepType(158))) &&
- (types(2).IsEqual(StepType(169))) &&
- (types(3).IsEqual(StepType(264)))) {
- return 327;
+ (types(2).IsEqual(StepType(169))) &&
+ (types(3).IsEqual(StepType(264)))) {
+ return 327;
} //pdn t3d_opt
else if ((types(1).IsEqual(StepType(169))) &&
- (types(2).IsEqual(StepType(264))) &&
- (types(3).IsEqual(StepType(158)))) {
- return 327;
+ (types(2).IsEqual(StepType(264))) &&
+ (types(3).IsEqual(StepType(158)))) {
+ return 327;
}
else if ((types(1).IsEqual(StepType(169))) &&
- (types(2).IsEqual(StepType(201))) &&
- (types(3).IsEqual(StepType(264)))) {
- return 328;
+ (types(2).IsEqual(StepType(201))) &&
+ (types(3).IsEqual(StepType(264)))) {
+ return 328;
}
else if ((types(1).IsEqual(StepType(79))) &&
- (types(2).IsEqual(StepType(158))) &&
- (types(3).IsEqual(StepType(169)))) {
- return 329;
+ (types(2).IsEqual(StepType(158))) &&
+ (types(3).IsEqual(StepType(169)))) {
+ return 329;
}
else if ((types(1).IsEqual(StepType(79))) &&
- (types(2).IsEqual(StepType(169))) &&
- (types(3).IsEqual(StepType(201)))) {
- return 330;
+ (types(2).IsEqual(StepType(169))) &&
+ (types(3).IsEqual(StepType(201)))) {
+ return 330;
}
else if ((types(1).IsEqual(StepType(143))) &&
- (types(2).IsEqual(StepType(149))) &&
- (types(3).IsEqual(StepType(246)))) {
- return 331;
+ (types(2).IsEqual(StepType(149))) &&
+ (types(3).IsEqual(StepType(246)))) {
+ return 331;
}
// Added by FMA
else if ((types(1).IsEqual(StepType(79))) &&
- (types(2).IsEqual(StepType(169))) &&
- (types(3).IsEqual(StepType(336)))) {
- return 334;
+ (types(2).IsEqual(StepType(169))) &&
+ (types(3).IsEqual(StepType(336)))) {
+ return 334;
}
else if ((types(1).IsEqual(StepType(169))) &&
- (types(2).IsEqual(StepType(264))) &&
- (types(3).IsEqual(StepType(336)))) {
- return 335;
+ (types(2).IsEqual(StepType(264))) &&
+ (types(3).IsEqual(StepType(336)))) {
+ return 335;
}
else if ((types(1).IsEqual(StepType(143))) &&
- (types(2).IsEqual(StepType(188))) &&
- (types(3).IsEqual(StepType(246)))) {
- return 338;
+ (types(2).IsEqual(StepType(188))) &&
+ (types(3).IsEqual(StepType(246)))) {
+ return 338;
}
// full Rev4 (CKY 30-MARS-1997)
else if ((types(1).IsEqual(StepType(169))) &&
- (types(2).IsEqual(StepType(342))) &&
- (types(3).IsEqual(StepType(264)))) {
- return 344;
+ (types(2).IsEqual(StepType(342))) &&
+ (types(3).IsEqual(StepType(264)))) {
+ return 344;
}
else if ((types(1).IsEqual(StepType(169))) &&
- (types(2).IsEqual(StepType(264))) &&
- (types(3).IsEqual(StepType(343)))) {
- return 345;
+ (types(2).IsEqual(StepType(264))) &&
+ (types(3).IsEqual(StepType(343)))) {
+ return 345;
}
else if ((types(1).IsEqual(StepType(79))) &&
- (types(2).IsEqual(StepType(169))) &&
- (types(3).IsEqual(StepType(342)))) {
- return 346;
+ (types(2).IsEqual(StepType(169))) &&
+ (types(3).IsEqual(StepType(342)))) {
+ return 346;
}
else if ((types(1).IsEqual(StepType(79))) &&
- (types(2).IsEqual(StepType(169))) &&
- (types(3).IsEqual(StepType(343)))) {
- return 347;
+ (types(2).IsEqual(StepType(169))) &&
+ (types(3).IsEqual(StepType(343)))) {
+ return 347;
}
else if ((types(1).IsEqual(StepType(157))) &&
- (types(2).IsEqual(StepType(165))) &&
- (types(3).IsEqual(StepType(310)))) {
- return 357; // LECTURE SEULEMENT (READ ONLY), origine CATIA. CKY 2-SEP-1997
+ (types(2).IsEqual(StepType(165))) &&
+ (types(3).IsEqual(StepType(310)))) {
+ return 357; // LECTURE SEULEMENT (READ ONLY), origine CATIA. CKY 2-SEP-1997
}
// Additional non-alphabetic (CKY 5 MAI 1998)
else if ((types(1).IsEqual(StepType(169))) &&
- (types(2).IsEqual(StepType(158))) &&
- (types(3).IsEqual(StepType(264)))) {
- return 327;
+ (types(2).IsEqual(StepType(158))) &&
+ (types(3).IsEqual(StepType(264)))) {
+ return 327;
}
// CC1 -> CC2 (CKY 1-JUL-1998)
else if ((types(1).IsEqual(StepType(249))) &&
- (types(2).IsEqual(StepType(388))) &&
- (types(3).IsEqual(StepType(387)))) {
- return 389;
+ (types(2).IsEqual(StepType(388))) &&
+ (types(3).IsEqual(StepType(387)))) {
+ return 389;
}
else if ((types(1).IsEqual(StepType(407))) &&
- (types(2).IsEqual(StepType(169))) &&
- (types(3).IsEqual(StepType(264)))) {
- return 409;
+ (types(2).IsEqual(StepType(169))) &&
+ (types(3).IsEqual(StepType(264)))) {
+ return 409;
}
else if ((types(1).IsEqual(StepType(169))) &&
- (types(2).IsEqual(StepType(264))) &&
- (types(3).IsEqual(StepType(408)))) {
- return 410;
+ (types(2).IsEqual(StepType(264))) &&
+ (types(3).IsEqual(StepType(408)))) {
+ return 410;
}
else if ((types(1).IsEqual(StepType(407))) &&
- (types(2).IsEqual(StepType(79))) &&
- (types(3).IsEqual(StepType(169)))) {
- return 411;
+ (types(2).IsEqual(StepType(79))) &&
+ (types(3).IsEqual(StepType(169)))) {
+ return 411;
}
else if ((types(1).IsEqual(StepType(79))) &&
- (types(2).IsEqual(StepType(169))) &&
- (types(3).IsEqual(StepType(408)))) {
- return 412;
+ (types(2).IsEqual(StepType(169))) &&
+ (types(3).IsEqual(StepType(408)))) {
+ return 412;
}
// abv 11.07.00: CAX-IF TRJ4: k1_geo-ac.stp
else if ((types(1).IsEqual(StepType(98))) &&
- (types(2).IsEqual(StepType(245))) &&
- (types(3).IsEqual(StepType(262)))) {
- return 463;
+ (types(2).IsEqual(StepType(245))) &&
+ (types(3).IsEqual(StepType(262)))) {
+ return 463;
}
// CKY 25 APR 2001; CAX-IF TR7J (dim.tol.)
else if ((types(1).IsEqual(StepType(406))) &&
- (types(2).IsEqual(StepType(480))) &&
- (types(3).IsEqual(StepType(247)))) {
- return 481;
+ (types(2).IsEqual(StepType(480))) &&
+ (types(3).IsEqual(StepType(247)))) {
+ return 481;
}
else if ((types(1).IsEqual(StepType(501))) &&
(types(2).IsEqual(StepType(169))) &&
(types(3).IsEqual(StepType(264)))) {
- return 574;
+ return 574;
}
else if ((types(1).IsEqual(StepType(169))) &&
(types(2).IsEqual(StepType(264))) &&
(types(3).IsEqual(StepType(502)))) {
- return 578;
+ return 578;
}
else if ((types(1).IsEqual(StepType(79))) &&
- (types(2).IsEqual(StepType(501))) &&
- (types(3).IsEqual(StepType(169)))) {
- return 650;
+ (types(2).IsEqual(StepType(501))) &&
+ (types(3).IsEqual(StepType(169)))) {
+ return 650;
}
- }
- if (NbComp == 4) {
- if ((types(1).IsEqual(StepType(161))) &&
- (types(2).IsEqual(StepType(189))) &&
- (types(3).IsEqual(StepType(247))) &&
- (types(4).IsEqual(StepType(304)))) {
- return 332;
- }
- // Added by FMA
- else if ((types(1).IsEqual(StepType(143)) &&
- types(2).IsEqual(StepType(148)) &&
- types(3).IsEqual(StepType(149)) &&
- types(4).IsEqual(StepType(246)))) {
- return 333;
- }
- }
- // Added by FMA
- if (NbComp == 6) {
- if (types(1).IsEqual(StepType(52)) &&
- types(2).IsEqual(StepType(134)) &&
- types(3).IsEqual(StepType(144)) &&
- types(4).IsEqual(StepType(162)) &&
- types(5).IsEqual(StepType(247)) &&
- types(6).IsEqual(StepType(266))) {
- return 337;
- }
- }
- else if (NbComp == 5) {
- //:n5 abv 15 Feb 99: S4132 complex type bounded_curve + surface_curve
- if ((types(1).IsEqual(StepType(48))) &&
- (types(2).IsEqual(StepType(84))) &&
- (types(3).IsEqual(StepType(144))) &&
- (types(4).IsEqual(StepType(247))) &&
- (types(5).IsEqual(StepType(272)))) {
- return 358;
+ else if (((types(1).IsEqual(StepType(609)) ||
+ types(1).IsEqual(StepType(611)) ||
+ types(1).IsEqual(StepType(612)) ||
+ types(1).IsEqual(StepType(613)) ||
+ types(1).IsEqual(StepType(614)) ||
+ types(1).IsEqual(StepType(615))) &&
+ types(2).IsEqual(StepType(625)) &&
+ types(3).IsEqual(StepType(627)))
+ ||
+ (types(1).IsEqual(StepType(625)) &&
+ types(2).IsEqual(StepType(627)) &&
+ (types(3).IsEqual(StepType(616)) ||
+ types(3).IsEqual(StepType(617)) ||
+ types(3).IsEqual(StepType(618)) ||
+ types(3).IsEqual(StepType(619)) ||
+ types(3).IsEqual(StepType(620)) ||
+ types(3).IsEqual(StepType(621)) ||
+ types(3).IsEqual(StepType(622)) ||
+ types(3).IsEqual(StepType(623)) ||
+ types(3).IsEqual(StepType(624))))) {
+ return 694;
}
- }
- else if (NbComp == 4) {
- if ((types(1).IsEqual(StepType(157))) &&
- (types(2).IsEqual(StepType(406))) &&
- (types(3).IsEqual(StepType(165))) &&
- (types(4).IsEqual(StepType(247)))) {
- return 635;
+ else if (((types(1).IsEqual(StepType(609)) ||
+ types(1).IsEqual(StepType(611)) ||
+ types(1).IsEqual(StepType(612)) ||
+ types(1).IsEqual(StepType(613)) ||
+ types(1).IsEqual(StepType(614)) ||
+ types(1).IsEqual(StepType(615))) &&
+ types(2).IsEqual(StepType(625)) &&
+ types(3).IsEqual(StepType(676)))
+ ||
+ (types(1).IsEqual(StepType(625)) &&
+ types(2).IsEqual(StepType(676)) &&
+ (types(3).IsEqual(StepType(616)) ||
+ types(3).IsEqual(StepType(617)) ||
+ types(3).IsEqual(StepType(618)) ||
+ types(3).IsEqual(StepType(619)) ||
+ types(3).IsEqual(StepType(620)) ||
+ types(3).IsEqual(StepType(621)) ||
+ types(3).IsEqual(StepType(622)) ||
+ types(3).IsEqual(StepType(623)) ||
+ types(3).IsEqual(StepType(624))))) {
+ return 696;
}
- if ((types(1).IsEqual(StepType(625))) &&
- (types(2).IsEqual(StepType(627))) &&
- (types(3).IsEqual(StepType(628))) &&
- (types(4).IsEqual(StepType(619)))) {
- return 636;
+ else if (types(1).IsEqual(StepType(470)) &&
+ types(2).IsEqual(StepType(630)) &&
+ types(3).IsEqual(StepType(258))) {
+ return 699;
}
}
return 0;
return Standard_True;
case 650:
return Standard_True;
+ case 691:
+ return Standard_True;
+ case 692:
+ return Standard_True;
+ case 693:
+ return Standard_True;
+ case 694:
+ return Standard_True;
+ case 695:
+ return Standard_True;
+ case 696:
+ return Standard_True;
+ case 697:
+ return Standard_True;
+ case 698:
+ return Standard_True;
+ case 699:
+ return Standard_True;
default:
return Standard_False;
}
case 601: return Reco_DocumentProductEquivalence;
// Added by SKL 18.06.2003 for Dimensional Tolerances (CAX-IF TRJ11)
+ case 609: return Reco_CylindricityTolerance;
case 610: return Reco_ShapeRepresentationWithParameters;
case 611: return Reco_AngularityTolerance;
case 612: return Reco_ConcentricityTolerance;
case 651 : return Reco_MassMeasureWithUnit;
+ // Added by ika for GD&T AP242
+ case 660: return Reco_Apex;
+ case 661: return Reco_CentreOfSymmetry;
+ case 662: return Reco_GeometricAlignment;
+ case 663: return Reco_PerpendicularTo;
+ case 664: return Reco_Tangent;
+ case 665: return Reco_ParallelOffset;
+ case 666: return Reco_GeometricItemSpecificUsage;
+ case 667: return Reco_IdAttribute;
+ case 668: return Reco_ItemIdentifiedRepresentationUsage;
+ case 669: return Reco_AllAroundShapeAspect;
+ case 670: return Reco_BetweenShapeAspect;
+ case 671: return Reco_CompositeGroupShapeAspect;
+ case 672: return Reco_ContinuosShapeAspect;
+ case 673: return Reco_GeometricToleranceWithDefinedAreaUnit;
+ case 674: return Reco_GeometricToleranceWithDefinedUnit;
+ case 675: return Reco_GeometricToleranceWithMaximumTolerance;
+ case 676: return Reco_GeometricToleranceWithModifiers;
+ case 677: return Reco_UnequallyDisposedGeometricTolerance;
+ case 678: return Reco_NonUniformZoneDefinition;
+ case 679: return Reco_ProjectedZoneDefinition;
+ case 680: return Reco_RunoutZoneDefinition;
+ case 681: return Reco_RunoutZoneOrientation;
+ case 682: return Reco_ToleranceZone;
+ case 683: return Reco_ToleranceZoneDefinition;
+ case 684: return Reco_ToleranceZoneForm;
+ case 685: return Reco_ValueFormatTypeQualifier;
+ case 686: return Reco_DatumReferenceCompartment;
+ case 687: return Reco_DatumReferenceElement;
+ case 688: return Reco_DatumReferenceModifierWithValue;
+ case 689: return Reco_DatumSystem;
+ case 690: return Reco_GeneralDatumReference;
+ case 700: return Reco_IntegerRepresentationItem;
+ case 701: return Reco_ValueRepresentationItem;
+
default : return PasReco;
}
}
types.Append (StepType(501));
types.Append (StepType(169));
break;
+ case 691:
+ types.Append (StepType(406));
+ types.Append (StepType(165));
+ types.Append (StepType(200));
+ types.Append (StepType(247));
+ break;
+ case 692:
+ types.Append (StepType(157));
+ types.Append (StepType(406));
+ types.Append (StepType(165));
+ types.Append (StepType(480));
+ types.Append (StepType(247));
+ break;
+ case 693:
+ types.Append (StepType(406));
+ types.Append (StepType(165));
+ types.Append (StepType(200));
+ types.Append (StepType(480));
+ types.Append (StepType(247));
+ break;
+ case 694:
+ types.Append (StepType(625));
+ types.Append (StepType(627));
+ types.Append (StepType(625));
+ break;
+ case 695:
+ types.Append (StepType(625));
+ types.Append (StepType(627));
+ types.Append (StepType(676));
+ types.Append (StepType(625));
+ break;
+ case 696:
+ types.Append (StepType(625));
+ types.Append (StepType(676));
+ types.Append (StepType(625));
+ break;
+ case 697:
+ types.Append (StepType(625));
+ types.Append (StepType(627));
+ types.Append (StepType(625));
+ types.Append (StepType(677));
+ break;
default : return Standard_False;
+ case 698:
+ types.Append (StepType(671));
+ types.Append (StepType(470));
+ types.Append (StepType(630));
+ types.Append (StepType(258));
+ break;
+ case 699:
+ types.Append (StepType(470));
+ types.Append (StepType(630));
+ types.Append (StepType(258));
+ break;
}
return Standard_True;
}
// Added by CKY 25 APR 2001 for CAX-IF TRJ7 (dimensional tolerances)
case 470:
+ {
+ DeclareAndCast(StepRepr_CompositeShapeAspect,anent,ent);
+ RWStepRepr_RWCompositeShapeAspect tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
case 471:
- case 472: // same as ShapeAspect
{
- DeclareAndCast(StepRepr_ShapeAspect,anent,ent);
- RWStepRepr_RWShapeAspect tool;
+ DeclareAndCast(StepRepr_DerivedShapeAspect,anent,ent);
+ RWStepRepr_RWDerivedShapeAspect tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 472:
+ {
+ DeclareAndCast(StepRepr_Extension,anent,ent);
+ RWStepRepr_RWExtension tool;
tool.ReadStep (data,num,ach,anent);
}
break;
tool.ReadStep (data,num,ach,anent);
}
break;
+ case 609:
+ {
+ DeclareAndCast(StepDimTol_CylindricityTolerance,anent,ent);
+ RWStepDimTol_RWCylindricityTolerance tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
case 610:
{
DeclareAndCast(StepShape_ShapeRepresentationWithParameters,anent,ent);
tool.ReadStep (data,num,ach,anent);
}
break;
+ case 660 :
+ {
+ DeclareAndCast(StepRepr_Apex, anent, ent);
+ RWStepRepr_RWApex tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 661 :
+ {
+ DeclareAndCast(StepRepr_CentreOfSymmetry, anent, ent);
+ RWStepRepr_RWCentreOfSymmetry tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 662 :
+ {
+ DeclareAndCast(StepRepr_GeometricAlignment, anent, ent);
+ RWStepRepr_RWGeometricAlignment tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 663 :
+ {
+ DeclareAndCast(StepRepr_PerpendicularTo, anent, ent);
+ RWStepRepr_RWPerpendicularTo tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 664 :
+ {
+ DeclareAndCast(StepRepr_Tangent, anent, ent);
+ RWStepRepr_RWTangent tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 665 :
+ {
+ DeclareAndCast(StepRepr_ParallelOffset, anent, ent);
+ RWStepRepr_RWParallelOffset tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 666 :
+ {
+ DeclareAndCast(StepAP242_GeometricItemSpecificUsage, anent, ent);
+ RWStepAP242_RWGeometricItemSpecificUsage tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 667 :
+ {
+ DeclareAndCast(StepAP242_IdAttribute, anent, ent);
+ RWStepAP242_RWIdAttribute tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 668 :
+ {
+ DeclareAndCast(StepAP242_ItemIdentifiedRepresentationUsage, anent, ent);
+ RWStepAP242_RWItemIdentifiedRepresentationUsage tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 669 :
+ {
+ DeclareAndCast(StepRepr_AllAroundShapeAspect, anent, ent);
+ RWStepRepr_RWAllAroundShapeAspect tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 670 :
+ {
+ DeclareAndCast(StepRepr_BetweenShapeAspect, anent, ent);
+ RWStepRepr_RWBetweenShapeAspect tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 671 :
+ {
+ DeclareAndCast(StepRepr_CompositeGroupShapeAspect, anent, ent);
+ RWStepRepr_RWCompositeGroupShapeAspect tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 672 :
+ {
+ DeclareAndCast(StepRepr_ContinuosShapeAspect, anent, ent);
+ RWStepRepr_RWContinuosShapeAspect tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 673 :
+ {
+ DeclareAndCast(StepDimTol_GeometricToleranceWithDefinedAreaUnit, anent, ent);
+ RWStepDimTol_RWGeometricToleranceWithDefinedAreaUnit tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 674 :
+ {
+ DeclareAndCast(StepDimTol_GeometricToleranceWithDefinedUnit, anent, ent);
+ RWStepDimTol_RWGeometricToleranceWithDefinedUnit tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 675 :
+ {
+ DeclareAndCast(StepDimTol_GeometricToleranceWithMaximumTolerance, anent, ent);
+ RWStepDimTol_RWGeometricToleranceWithMaximumTolerance tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 676 :
+ {
+ DeclareAndCast(StepDimTol_GeometricToleranceWithModifiers, anent, ent);
+ RWStepDimTol_RWGeometricToleranceWithModifiers tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 677 :
+ {
+ DeclareAndCast(StepDimTol_UnequallyDisposedGeometricTolerance, anent, ent);
+ RWStepDimTol_RWUnequallyDisposedGeometricTolerance tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 678 :
+ {
+ DeclareAndCast(StepDimTol_NonUniformZoneDefinition, anent, ent);
+ RWStepDimTol_RWNonUniformZoneDefinition tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 679 :
+ {
+ DeclareAndCast(StepDimTol_ProjectedZoneDefinition, anent, ent);
+ RWStepDimTol_RWProjectedZoneDefinition tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 680 :
+ {
+ DeclareAndCast(StepDimTol_RunoutZoneDefinition, anent, ent);
+ RWStepDimTol_RWRunoutZoneDefinition tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 681 :
+ {
+ DeclareAndCast(StepDimTol_RunoutZoneOrientation, anent, ent);
+ RWStepDimTol_RWRunoutZoneOrientation tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 682 :
+ {
+ DeclareAndCast(StepDimTol_ToleranceZone, anent, ent);
+ RWStepDimTol_RWToleranceZone tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 683 :
+ {
+ DeclareAndCast(StepDimTol_ToleranceZoneDefinition, anent, ent);
+ RWStepDimTol_RWToleranceZoneDefinition tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 684 :
+ {
+ DeclareAndCast(StepDimTol_ToleranceZoneForm, anent, ent);
+ RWStepDimTol_RWToleranceZoneForm tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 685 :
+ {
+ DeclareAndCast(StepShape_ValueFormatTypeQualifier, anent, ent);
+ RWStepShape_RWValueFormatTypeQualifier tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 686 :
+ {
+ DeclareAndCast(StepDimTol_DatumReferenceCompartment, anent, ent);
+ RWStepDimTol_RWDatumReferenceCompartment tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 687 :
+ {
+ DeclareAndCast(StepDimTol_DatumReferenceElement, anent, ent);
+ RWStepDimTol_RWDatumReferenceElement tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 688 :
+ {
+ DeclareAndCast(StepDimTol_DatumReferenceModifierWithValue, anent, ent);
+ RWStepDimTol_RWDatumReferenceModifierWithValue tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 689 :
+ {
+ DeclareAndCast(StepDimTol_DatumSystem, anent, ent);
+ RWStepDimTol_RWDatumSystem tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 690 :
+ {
+ DeclareAndCast(StepDimTol_GeneralDatumReference, anent, ent);
+ RWStepDimTol_RWGeneralDatumReference tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 691:
+ {
+ DeclareAndCast(StepRepr_ReprItemAndPlaneAngleMeasureWithUnit,anent,ent);
+ RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnit tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 692:
+ {
+ DeclareAndCast(StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI,anent,ent);
+ RWStepRepr_RWReprItemAndLengthMeasureWithUnitAndQRI tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 693:
+ {
+ DeclareAndCast(StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI,anent,ent);
+ RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnitAndQRI tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 694:
+ {
+ DeclareAndCast(StepDimTol_GeoTolAndGeoTolWthDatRef,anent,ent);
+ RWStepDimTol_RWGeoTolAndGeoTolWthDatRef tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 695:
+ {
+ DeclareAndCast(StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod,anent,ent);
+ RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMod tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 696:
+ {
+ DeclareAndCast(StepDimTol_GeoTolAndGeoTolWthMod,anent,ent);
+ RWStepDimTol_RWGeoTolAndGeoTolWthMod tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 697:
+ {
+ DeclareAndCast(StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol,anent,ent);
+ RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndUneqDisGeoTol tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 698:
+ {
+ DeclareAndCast(StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp,anent,ent);
+ RWStepRepr_RWCompGroupShAspAndCompShAspAndDatumFeatAndShAsp tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 699:
+ {
+ DeclareAndCast(StepRepr_CompShAspAndDatumFeatAndShAsp,anent,ent);
+ RWStepRepr_RWCompShAspAndDatumFeatAndShAsp tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 700:
+ {
+ DeclareAndCast(StepRepr_IntegerRepresentationItem,anent,ent);
+ RWStepRepr_RWIntegerRepresentationItem tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
+ case 701:
+ {
+ DeclareAndCast(StepRepr_ValueRepresentationItem,anent,ent);
+ RWStepRepr_RWValueRepresentationItem tool;
+ tool.ReadStep (data,num,ach,anent);
+ }
+ break;
default:
ach->AddFail("Type Mismatch when reading - Entity");
// Added by CKY 25 APR 2001 for CAX-IF TRJ7 (dimensional tolerances)
case 470:
+ {
+ DeclareAndCast(StepRepr_CompositeShapeAspect,anent,ent);
+ RWStepRepr_RWCompositeShapeAspect tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
case 471:
- case 472: // same as ShapeAspect
{
- DeclareAndCast(StepRepr_ShapeAspect,anent,ent);
- RWStepRepr_RWShapeAspect tool;
+ DeclareAndCast(StepRepr_DerivedShapeAspect,anent,ent);
+ RWStepRepr_RWDerivedShapeAspect tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 472:
+ {
+ DeclareAndCast(StepRepr_Extension,anent,ent);
+ RWStepRepr_RWExtension tool;
tool.WriteStep (SW,anent);
}
break;
tool.WriteStep (SW,anent);
}
break;
+ case 609:
+ {
+ DeclareAndCast(StepDimTol_CylindricityTolerance,anent,ent);
+ RWStepDimTol_RWCylindricityTolerance tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
case 610:
{
DeclareAndCast(StepShape_ShapeRepresentationWithParameters,anent,ent);
tool.WriteStep (SW,anent);
}
break;
+ case 660 :
+ {
+ DeclareAndCast(StepRepr_Apex, anent, ent);
+ RWStepRepr_RWApex tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 661 :
+ {
+ DeclareAndCast(StepRepr_CentreOfSymmetry, anent, ent);
+ RWStepRepr_RWCentreOfSymmetry tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 662 :
+ {
+ DeclareAndCast(StepRepr_GeometricAlignment, anent, ent);
+ RWStepRepr_RWGeometricAlignment tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 663 :
+ {
+ DeclareAndCast(StepRepr_PerpendicularTo, anent, ent);
+ RWStepRepr_RWPerpendicularTo tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 664 :
+ {
+ DeclareAndCast(StepRepr_Tangent, anent, ent);
+ RWStepRepr_RWTangent tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 665 :
+ {
+ DeclareAndCast(StepRepr_ParallelOffset, anent, ent);
+ RWStepRepr_RWParallelOffset tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 666 :
+ {
+ DeclareAndCast(StepAP242_GeometricItemSpecificUsage, anent, ent);
+ RWStepAP242_RWGeometricItemSpecificUsage tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 667 :
+ {
+ DeclareAndCast(StepAP242_IdAttribute, anent, ent);
+ RWStepAP242_RWIdAttribute tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 668 :
+ {
+ DeclareAndCast(StepAP242_ItemIdentifiedRepresentationUsage, anent, ent);
+ RWStepAP242_RWItemIdentifiedRepresentationUsage tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 669 :
+ {
+ DeclareAndCast(StepRepr_AllAroundShapeAspect, anent, ent);
+ RWStepRepr_RWAllAroundShapeAspect tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 670 :
+ {
+ DeclareAndCast(StepRepr_BetweenShapeAspect, anent, ent);
+ RWStepRepr_RWBetweenShapeAspect tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 671 :
+ {
+ DeclareAndCast(StepRepr_CompositeGroupShapeAspect, anent, ent);
+ RWStepRepr_RWCompositeGroupShapeAspect tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 672 :
+ {
+ DeclareAndCast(StepRepr_ContinuosShapeAspect, anent, ent);
+ RWStepRepr_RWContinuosShapeAspect tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 673 :
+ {
+ DeclareAndCast(StepDimTol_GeometricToleranceWithDefinedAreaUnit, anent, ent);
+ RWStepDimTol_RWGeometricToleranceWithDefinedAreaUnit tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 674 :
+ {
+ DeclareAndCast(StepDimTol_GeometricToleranceWithDefinedUnit, anent, ent);
+ RWStepDimTol_RWGeometricToleranceWithDefinedUnit tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 675 :
+ {
+ DeclareAndCast(StepDimTol_GeometricToleranceWithMaximumTolerance, anent, ent);
+ RWStepDimTol_RWGeometricToleranceWithMaximumTolerance tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 676 :
+ {
+ DeclareAndCast(StepDimTol_GeometricToleranceWithModifiers, anent, ent);
+ RWStepDimTol_RWGeometricToleranceWithModifiers tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 677 :
+ {
+ DeclareAndCast(StepDimTol_UnequallyDisposedGeometricTolerance, anent, ent);
+ RWStepDimTol_RWUnequallyDisposedGeometricTolerance tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 678 :
+ {
+ DeclareAndCast(StepDimTol_NonUniformZoneDefinition, anent, ent);
+ RWStepDimTol_RWNonUniformZoneDefinition tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 679 :
+ {
+ DeclareAndCast(StepDimTol_ProjectedZoneDefinition, anent, ent);
+ RWStepDimTol_RWProjectedZoneDefinition tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 680 :
+ {
+ DeclareAndCast(StepDimTol_RunoutZoneDefinition, anent, ent);
+ RWStepDimTol_RWRunoutZoneDefinition tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 681 :
+ {
+ DeclareAndCast(StepDimTol_RunoutZoneOrientation, anent, ent);
+ RWStepDimTol_RWRunoutZoneOrientation tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 682 :
+ {
+ DeclareAndCast(StepDimTol_ToleranceZone, anent, ent);
+ RWStepDimTol_RWToleranceZone tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 683 :
+ {
+ DeclareAndCast(StepDimTol_ToleranceZoneDefinition, anent, ent);
+ RWStepDimTol_RWToleranceZoneDefinition tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 684 :
+ {
+ DeclareAndCast(StepDimTol_ToleranceZoneForm, anent, ent);
+ RWStepDimTol_RWToleranceZoneForm tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 685 :
+ {
+ DeclareAndCast(StepShape_ValueFormatTypeQualifier, anent, ent);
+ RWStepShape_RWValueFormatTypeQualifier tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 686 :
+ {
+ DeclareAndCast(StepDimTol_DatumReferenceCompartment, anent, ent);
+ RWStepDimTol_RWDatumReferenceCompartment tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 687 :
+ {
+ DeclareAndCast(StepDimTol_DatumReferenceElement, anent, ent);
+ RWStepDimTol_RWDatumReferenceElement tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 688 :
+ {
+ DeclareAndCast(StepDimTol_DatumReferenceModifierWithValue, anent, ent);
+ RWStepDimTol_RWDatumReferenceModifierWithValue tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 689 :
+ {
+ DeclareAndCast(StepDimTol_DatumSystem, anent, ent);
+ RWStepDimTol_RWDatumSystem tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 690 :
+ {
+ DeclareAndCast(StepDimTol_GeneralDatumReference, anent, ent);
+ RWStepDimTol_RWGeneralDatumReference tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 691:
+ {
+ DeclareAndCast(StepRepr_ReprItemAndPlaneAngleMeasureWithUnit,anent,ent);
+ RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnit tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 692:
+ {
+ DeclareAndCast(StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI,anent,ent);
+ RWStepRepr_RWReprItemAndLengthMeasureWithUnitAndQRI tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 693:
+ {
+ DeclareAndCast(StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI,anent,ent);
+ RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnitAndQRI tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 694:
+ {
+ DeclareAndCast(StepDimTol_GeoTolAndGeoTolWthDatRef,anent,ent);
+ RWStepDimTol_RWGeoTolAndGeoTolWthDatRef tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 695:
+ {
+ DeclareAndCast(StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod,anent,ent);
+ RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMod tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 696:
+ {
+ DeclareAndCast(StepDimTol_GeoTolAndGeoTolWthMod,anent,ent);
+ RWStepDimTol_RWGeoTolAndGeoTolWthMod tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 697:
+ {
+ DeclareAndCast(StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol,anent,ent);
+ RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndUneqDisGeoTol tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 698:
+ {
+ DeclareAndCast(StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp,anent,ent);
+ RWStepRepr_RWCompGroupShAspAndCompShAspAndDatumFeatAndShAsp tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 699:
+ {
+ DeclareAndCast(StepRepr_CompShAspAndDatumFeatAndShAsp,anent,ent);
+ RWStepRepr_RWCompShAspAndDatumFeatAndShAsp tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 700:
+ {
+ DeclareAndCast(StepRepr_IntegerRepresentationItem,anent,ent);
+ RWStepRepr_RWIntegerRepresentationItem tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
+ case 701:
+ {
+ DeclareAndCast(StepRepr_ValueRepresentationItem,anent,ent);
+ RWStepRepr_RWValueRepresentationItem tool;
+ tool.WriteStep (SW,anent);
+ }
+ break;
default:
return;
--- /dev/null
+RWStepAP242_RWGeometricItemSpecificUsage.cxx
+RWStepAP242_RWGeometricItemSpecificUsage.hxx
+RWStepAP242_RWIdAttribute.cxx
+RWStepAP242_RWIdAttribute.hxx
+RWStepAP242_RWItemIdentifiedRepresentationUsage.cxx
+RWStepAP242_RWItemIdentifiedRepresentationUsage.hxx
--- /dev/null
+// Created on: 2015-07-07
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepAP242_RWGeometricItemSpecificUsage.hxx>
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepAP242_GeometricItemSpecificUsage.hxx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepRepr_Representation.hxx>
+
+
+RWStepAP242_RWGeometricItemSpecificUsage::RWStepAP242_RWGeometricItemSpecificUsage () {}
+
+void RWStepAP242_RWGeometricItemSpecificUsage::ReadStep
+ (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepAP242_GeometricItemSpecificUsage)& ent) const
+{
+
+
+ // --- Number of Parameter Control ---
+
+ if (!data->CheckNbParams(num,5,ach,"geometric_item_specific_usage")) return;
+
+ // Inherited fields of ItemIdentifiedRepresentationUsage
+
+ Handle(TCollection_HAsciiString) aName;
+ data->ReadString (num,1,"item_identified_representation_usage.name",ach,aName);
+
+ Handle(TCollection_HAsciiString) aDescription;
+ if (data->IsParamDefined (num,2)) {
+ data->ReadString (num,2,"item_identified_representation_usage.description",ach,aDescription);
+ }
+
+ StepAP242_ItemIdentifiedRepresentationUsageDefinition aDefinition;
+ data->ReadEntity(num,3,"item_identified_representation_usage.definition",ach,aDefinition);
+
+ Handle(StepRepr_Representation) aRepresentation;
+ data->ReadEntity (num,4,"item_identified_representation_usage.used_representation",ach,STANDARD_TYPE(StepRepr_Representation), aRepresentation);
+
+ Handle(StepRepr_HArray1OfRepresentationItem) anItems;
+ Handle(StepRepr_RepresentationItem) anEnt;
+ Standard_Integer nbSub;
+ Interface_ParamType aType = data->ParamType(num, 5);
+ if (aType == Interface_ParamIdent) {
+ data->ReadEntity(num, 5,"item_identified_representation_usage.identified_item", ach, STANDARD_TYPE(StepRepr_RepresentationItem), anEnt);
+ anItems = new StepRepr_HArray1OfRepresentationItem (1, 1);
+ anItems->SetValue(1, anEnt);
+ }
+ else if (data->ReadSubList (num,5,"item_identified_representation_usage.identified_item",ach,nbSub)) {
+ Standard_Integer nbElements = data->NbParams(nbSub);
+ anItems = new StepRepr_HArray1OfRepresentationItem (1, nbElements);
+ for (Standard_Integer i = 1; i <= nbElements; i++) {
+ if (data->ReadEntity(nbSub, i,"representation_item", ach,
+ STANDARD_TYPE(StepRepr_RepresentationItem), anEnt))
+ anItems->SetValue(i, anEnt);
+ }
+ }
+
+ //--- Initialisation of the read entity ---
+
+ ent->Init(aName, aDescription, aDefinition, aRepresentation, anItems);
+}
+
+void RWStepAP242_RWGeometricItemSpecificUsage::WriteStep
+ (StepData_StepWriter& SW,
+ const Handle(StepAP242_GeometricItemSpecificUsage)& ent) const
+{
+ // Inherited fields of ItemIdentifiedRepresentationUsage
+
+ SW.Send(ent->Name());
+
+ SW.Send(ent->Description());
+
+ SW.Send(ent->Definition().Value());
+
+ SW.Send(ent->UsedRepresentation());
+
+ if (ent->NbIdentifiedItem() == 1)
+ SW.Send(ent->IdentifiedItemValue(1));
+ else {
+ SW.OpenSub();
+ for (Standard_Integer i = 1; i <= ent->NbIdentifiedItem(); i++) {
+ SW.Send(ent->IdentifiedItemValue(i));
+ }
+ SW.CloseSub();
+ }
+}
+
+void RWStepAP242_RWGeometricItemSpecificUsage::Share(
+ const Handle(StepAP242_GeometricItemSpecificUsage)& ent,
+ Interface_EntityIterator& iter) const
+{
+ // Inherited fields of ItemIdentifiedRepresentationUsage
+
+ iter.AddItem(ent->Definition().Value());
+ Standard_Integer i, nb = ent->NbIdentifiedItem();
+ for (i = 1; i <= nb; i++)
+ iter.AddItem (ent->IdentifiedItemValue(i));
+}
+
--- /dev/null
+// Created on: 2015-07-07
+// Created by: Irina KRYLOVA
+// 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 _RWStepAP242_RWGeometricItemSpecificUsage_HeaderFile
+#define _RWStepAP242_RWGeometricItemSpecificUsage_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepAP242_GeometricItemSpecificUsage;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write Module for GeometricItemSpecificUsage
+class RWStepAP242_RWGeometricItemSpecificUsage
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ Standard_EXPORT RWStepAP242_RWGeometricItemSpecificUsage();
+
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepAP242_GeometricItemSpecificUsage)& ent) const;
+
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepAP242_GeometricItemSpecificUsage)& ent) const;
+
+ Standard_EXPORT void Share (const Handle(StepAP242_GeometricItemSpecificUsage)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepAP242_RWGeometricItemSpecificUsage_HeaderFile
--- /dev/null
+// Created on: 2015-07-07
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepAP242_RWIdAttribute.hxx>
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepAP242_IdAttribute.hxx>
+#include <StepAP242_IdAttributeSelect.hxx>
+
+RWStepAP242_RWIdAttribute::RWStepAP242_RWIdAttribute () {}
+
+void RWStepAP242_RWIdAttribute::ReadStep
+ (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepAP242_IdAttribute)& ent) const
+{
+
+
+ // --- Number of Parameter Control ---
+
+ if (!data->CheckNbParams(num,2,ach,"id_attribute")) return;
+
+ // --- own field : attribute_value ---
+
+ Handle(TCollection_HAsciiString) anAttributeValue;
+ data->ReadString (num,1,"attribute_value",ach,anAttributeValue);
+
+ // --- own field : identified_item ---
+
+ StepAP242_IdAttributeSelect anIdentifiedItem;
+ data->ReadEntity (num,2,"identified_item",ach,anIdentifiedItem);
+
+ //--- Initialisation of the read entity ---
+
+ ent->Init(anAttributeValue, anIdentifiedItem);
+}
+
+void RWStepAP242_RWIdAttribute::WriteStep
+ (StepData_StepWriter& SW,
+ const Handle(StepAP242_IdAttribute)& ent) const
+{
+
+ // --- own field : attribute_value ---
+
+ SW.Send(ent->AttributeValue());
+
+ // --- own field : identified_item ---
+
+ SW.Send(ent->IdentifiedItem().Value());
+}
+
+void RWStepAP242_RWIdAttribute::Share(const Handle(StepAP242_IdAttribute)& ent, Interface_EntityIterator& iter) const
+{
+ iter.GetOneItem(ent->IdentifiedItem().Value());
+}
+
--- /dev/null
+// Created on: 2015-07-07
+// Created by: Irina KRYLOVA
+// 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 _RWStepAP242_RWIdAttribute_HeaderFile
+#define _RWStepAP242_RWIdAttribute_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepAP242_IdAttribute;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write Module for IdAttribute
+class RWStepAP242_RWIdAttribute
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ Standard_EXPORT RWStepAP242_RWIdAttribute();
+
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepAP242_IdAttribute)& ent) const;
+
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepAP242_IdAttribute)& ent) const;
+
+ Standard_EXPORT void Share (const Handle(StepAP242_IdAttribute)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepAP242_RWIdAttribute_HeaderFile
--- /dev/null
+// Created on: 2015-07-07
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepAP242_RWItemIdentifiedRepresentationUsage.hxx>
+#include <Interface_EntityIterator.hxx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepAP242_ItemIdentifiedRepresentationUsage.hxx>
+#include <StepAP242_ItemIdentifiedRepresentationUsageDefinition.hxx>
+#include <StepRepr_Representation.hxx>
+
+
+RWStepAP242_RWItemIdentifiedRepresentationUsage::RWStepAP242_RWItemIdentifiedRepresentationUsage () {}
+
+void RWStepAP242_RWItemIdentifiedRepresentationUsage::ReadStep
+ (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepAP242_ItemIdentifiedRepresentationUsage)& ent) const
+{
+ // --- Number of Parameter Control ---
+
+ if (!data->CheckNbParams(num,5,ach,"item_identified_representation_usage")) return;
+
+ // --- own field : name ---
+
+ Handle(TCollection_HAsciiString) aName;
+ data->ReadString (num,1,"name",ach,aName);
+
+ // --- own field : description ---
+
+ Handle(TCollection_HAsciiString) aDescription;
+ if (data->IsParamDefined (num,2)) {
+ data->ReadString (num,2,"description",ach,aDescription);
+ }
+ // --- own field : definition ---
+
+ StepAP242_ItemIdentifiedRepresentationUsageDefinition aDefinition;
+ data->ReadEntity(num,3,"definition",ach,aDefinition);
+
+ // --- own field : used_representation ---
+
+ Handle(StepRepr_Representation) aRepresentation;
+ data->ReadEntity (num,4,"used_representation",ach,STANDARD_TYPE(StepRepr_Representation), aRepresentation);
+
+ // --- own field : identified_item
+
+ Handle(StepRepr_HArray1OfRepresentationItem) anItems;
+ Handle(StepRepr_RepresentationItem) anEnt;
+ Standard_Integer nbSub;
+ Interface_ParamType aType = data->ParamType(num, 5);
+ if (aType == Interface_ParamIdent) {
+ data->ReadEntity(num, 5,"item_identified_representation_usage.identified_item", ach, STANDARD_TYPE(StepRepr_RepresentationItem), anEnt);
+ anItems = new StepRepr_HArray1OfRepresentationItem (1, 1);
+ anItems->SetValue(1, anEnt);
+ }
+ else if (data->ReadSubList (num,5,"item_identified_representation_usage.identified_item",ach,nbSub)) {
+ Standard_Integer nbElements = data->NbParams(nbSub);
+ anItems = new StepRepr_HArray1OfRepresentationItem (1, nbElements);
+ for (Standard_Integer i = 1; i <= nbElements; i++) {
+ if (data->ReadEntity(nbSub, i,"representation_item", ach,
+ STANDARD_TYPE(StepRepr_RepresentationItem), anEnt))
+ anItems->SetValue(i, anEnt);
+ }
+ }
+
+ //--- Initialisation of the read entity ---
+
+
+ ent->Init(aName, aDescription, aDefinition, aRepresentation, anItems);
+}
+
+
+void RWStepAP242_RWItemIdentifiedRepresentationUsage::WriteStep
+ (StepData_StepWriter& SW,
+ const Handle(StepAP242_ItemIdentifiedRepresentationUsage)& ent) const
+{
+
+ // --- own field : name ---
+
+ SW.Send(ent->Name());
+
+ // --- own field : description ---
+
+ SW.Send(ent->Description());
+
+ // --- own field : definition ---
+
+ SW.Send(ent->Definition().Value());
+
+ // --- own field : used_representation ---
+
+ SW.Send(ent->UsedRepresentation());
+
+ // --- own field : identified_item ---
+
+ if (ent->NbIdentifiedItem() == 1)
+ SW.Send(ent->IdentifiedItemValue(1));
+ else {
+ SW.OpenSub();
+ for (Standard_Integer i = 1; i <= ent->NbIdentifiedItem(); i++) {
+ SW.Send(ent->IdentifiedItemValue(i));
+ }
+ SW.CloseSub();
+ }
+}
+
+
+void RWStepAP242_RWItemIdentifiedRepresentationUsage::Share(
+ const Handle(StepAP242_ItemIdentifiedRepresentationUsage)& ent,
+ Interface_EntityIterator& iter) const
+{
+ iter.AddItem(ent->Definition().Value());
+ Standard_Integer i, nb = ent->NbIdentifiedItem();
+ for (i = 1; i <= nb; i++)
+ iter.AddItem (ent->IdentifiedItemValue(i));
+}
+
--- /dev/null
+// Created on: 2015-07-07
+// Created by: Irina KRYLOVA
+// 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 _RWStepAP242_RWItemIdentifiedRepresentationUsage_HeaderFile
+#define _RWStepAP242_RWItemIdentifiedRepresentationUsage_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepAP242_ItemIdentifiedRepresentationUsage;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write Module for ItemIdentifiedRepresentationUsage
+class RWStepAP242_RWItemIdentifiedRepresentationUsage
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ Standard_EXPORT RWStepAP242_RWItemIdentifiedRepresentationUsage();
+
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepAP242_ItemIdentifiedRepresentationUsage)& ent) const;
+
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepAP242_ItemIdentifiedRepresentationUsage)& ent) const;
+
+ Standard_EXPORT void Share (const Handle(StepAP242_ItemIdentifiedRepresentationUsage)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepAP242_RWItemIdentifiedRepresentationUsage_HeaderFile
RWStepDimTol_RWDatumFeature.hxx
RWStepDimTol_RWDatumReference.cxx
RWStepDimTol_RWDatumReference.hxx
+RWStepDimTol_RWDatumReferenceCompartment.cxx
+RWStepDimTol_RWDatumReferenceCompartment.hxx
+RWStepDimTol_RWDatumReferenceElement.cxx
+RWStepDimTol_RWDatumReferenceElement.hxx
+RWStepDimTol_RWDatumReferenceModifierWithValue.cxx
+RWStepDimTol_RWDatumReferenceModifierWithValue.hxx
+RWStepDimTol_RWDatumSystem.cxx
+RWStepDimTol_RWDatumSystem.hxx
RWStepDimTol_RWDatumTarget.cxx
RWStepDimTol_RWDatumTarget.hxx
RWStepDimTol_RWFlatnessTolerance.cxx
RWStepDimTol_RWFlatnessTolerance.hxx
+RWStepDimTol_RWGeneralDatumReference.cxx
+RWStepDimTol_RWGeneralDatumReference.hxx
RWStepDimTol_RWGeometricTolerance.cxx
RWStepDimTol_RWGeometricTolerance.hxx
RWStepDimTol_RWGeometricToleranceRelationship.cxx
RWStepDimTol_RWGeometricToleranceRelationship.hxx
RWStepDimTol_RWGeometricToleranceWithDatumReference.cxx
RWStepDimTol_RWGeometricToleranceWithDatumReference.hxx
+RWStepDimTol_RWGeometricToleranceWithDefinedAreaUnit.cxx
+RWStepDimTol_RWGeometricToleranceWithDefinedAreaUnit.hxx
+RWStepDimTol_RWGeometricToleranceWithDefinedUnit.cxx
+RWStepDimTol_RWGeometricToleranceWithDefinedUnit.hxx
+RWStepDimTol_RWGeometricToleranceWithMaximumTolerance.cxx
+RWStepDimTol_RWGeometricToleranceWithMaximumTolerance.hxx
+RWStepDimTol_RWGeometricToleranceWithModifiers.cxx
+RWStepDimTol_RWGeometricToleranceWithModifiers.hxx
+RWStepDimTol_RWGeoTolAndGeoTolWthDatRef.cxx
+RWStepDimTol_RWGeoTolAndGeoTolWthDatRef.hxx
+RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMod.cxx
+RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMod.hxx
RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndModGeoTolAndPosTol.cxx
RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndModGeoTolAndPosTol.hxx
+RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndUneqDisGeoTol.cxx
+RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndUneqDisGeoTol.hxx
+RWStepDimTol_RWGeoTolAndGeoTolWthMod.cxx
+RWStepDimTol_RWGeoTolAndGeoTolWthMod.hxx
RWStepDimTol_RWLineProfileTolerance.cxx
RWStepDimTol_RWLineProfileTolerance.hxx
RWStepDimTol_RWModifiedGeometricTolerance.cxx
RWStepDimTol_RWModifiedGeometricTolerance.hxx
+RWStepDimTol_RWNonUniformZoneDefinition.cxx
+RWStepDimTol_RWNonUniformZoneDefinition.hxx
RWStepDimTol_RWParallelismTolerance.cxx
RWStepDimTol_RWParallelismTolerance.hxx
RWStepDimTol_RWPerpendicularityTolerance.cxx
RWStepDimTol_RWPlacedDatumTargetFeature.hxx
RWStepDimTol_RWPositionTolerance.cxx
RWStepDimTol_RWPositionTolerance.hxx
+RWStepDimTol_RWProjectedZoneDefinition.cxx
+RWStepDimTol_RWProjectedZoneDefinition.hxx
RWStepDimTol_RWRoundnessTolerance.cxx
RWStepDimTol_RWRoundnessTolerance.hxx
+RWStepDimTol_RWRunoutZoneDefinition.cxx
+RWStepDimTol_RWRunoutZoneDefinition.hxx
+RWStepDimTol_RWRunoutZoneOrientation.cxx
+RWStepDimTol_RWRunoutZoneOrientation.hxx
RWStepDimTol_RWStraightnessTolerance.cxx
RWStepDimTol_RWStraightnessTolerance.hxx
RWStepDimTol_RWSurfaceProfileTolerance.cxx
RWStepDimTol_RWSurfaceProfileTolerance.hxx
RWStepDimTol_RWSymmetryTolerance.cxx
RWStepDimTol_RWSymmetryTolerance.hxx
+RWStepDimTol_RWToleranceZone.cxx
+RWStepDimTol_RWToleranceZone.hxx
+RWStepDimTol_RWToleranceZoneDefinition.cxx
+RWStepDimTol_RWToleranceZoneDefinition.hxx
+RWStepDimTol_RWToleranceZoneForm.cxx
+RWStepDimTol_RWToleranceZoneForm.hxx
RWStepDimTol_RWTotalRunoutTolerance.cxx
RWStepDimTol_RWTotalRunoutTolerance.hxx
+RWStepDimTol_RWUnequallyDisposedGeometricTolerance.cxx
+RWStepDimTol_RWUnequallyDisposedGeometricTolerance.hxx
#include <StepData_StepWriter.hxx>
#include <StepDimTol_AngularityTolerance.hxx>
#include <StepDimTol_DatumReference.hxx>
-#include <StepDimTol_HArray1OfDatumReference.hxx>
-#include <StepRepr_ShapeAspect.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
+#include <StepDimTol_HArray1OfDatumSystemOrReference.hxx>
//=======================================================================
//function : RWStepDimTol_RWAngularityTolerance
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
- Handle(StepRepr_ShapeAspect) aGeometricTolerance_TolerancedShapeAspect;
- data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, STANDARD_TYPE(StepRepr_ShapeAspect), aGeometricTolerance_TolerancedShapeAspect);
+ StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
+ data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
// Inherited fields of GeometricToleranceWithDatumReference
- Handle(StepDimTol_HArray1OfDatumReference) aGeometricToleranceWithDatumReference_DatumSystem;
+ Handle(StepDimTol_HArray1OfDatumSystemOrReference) aGeometricToleranceWithDatumReference_DatumSystem;
Standard_Integer sub5 = 0;
if ( data->ReadSubList (num, 5, "geometric_tolerance_with_datum_reference.datum_system", ach, sub5) ) {
Standard_Integer nb0 = data->NbParams(sub5);
- aGeometricToleranceWithDatumReference_DatumSystem = new StepDimTol_HArray1OfDatumReference (1, nb0);
+ aGeometricToleranceWithDatumReference_DatumSystem = new StepDimTol_HArray1OfDatumSystemOrReference (1, nb0);
Standard_Integer num2 = sub5;
for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
- Handle(StepDimTol_DatumReference) anIt0;
- data->ReadEntity (num2, i0, "datum_reference", ach, STANDARD_TYPE(StepDimTol_DatumReference), anIt0);
+ StepDimTol_DatumSystemOrReference anIt0;
+ data->ReadEntity (num2, i0, "datum_system_or_reference", ach, anIt0);
aGeometricToleranceWithDatumReference_DatumSystem->SetValue(i0, anIt0);
}
}
SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
- SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
// Inherited fields of GeometricToleranceWithDatumReference
SW.OpenSub();
- for (Standard_Integer i4=1; i4 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Length(); i4++ ) {
- Handle(StepDimTol_DatumReference) Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Value(i4);
- SW.Send (Var0);
+ for (Standard_Integer i4=1; i4 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Length(); i4++ ) {
+ StepDimTol_DatumSystemOrReference Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Value(i4);
+ SW.Send (Var0.Value());
}
SW.CloseSub();
}
iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
- iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
// Inherited fields of GeometricToleranceWithDatumReference
- for (Standard_Integer i3=1; i3 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Length(); i3++ ) {
- Handle(StepDimTol_DatumReference) Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Value(i3);
- iter.AddItem (Var0);
+ for (Standard_Integer i3=1; i3 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Length(); i3++ ) {
+ StepDimTol_DatumSystemOrReference Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Value(i3);
+ iter.AddItem (Var0.Value());
}
}
#include <StepData_StepWriter.hxx>
#include <StepDimTol_CircularRunoutTolerance.hxx>
#include <StepDimTol_DatumReference.hxx>
-#include <StepDimTol_HArray1OfDatumReference.hxx>
-#include <StepRepr_ShapeAspect.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
+#include <StepDimTol_HArray1OfDatumSystemOrReference.hxx>
//=======================================================================
//function : RWStepDimTol_RWCircularRunoutTolerance
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
- Handle(StepRepr_ShapeAspect) aGeometricTolerance_TolerancedShapeAspect;
- data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, STANDARD_TYPE(StepRepr_ShapeAspect), aGeometricTolerance_TolerancedShapeAspect);
+ StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
+ data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
// Inherited fields of GeometricToleranceWithDatumReference
- Handle(StepDimTol_HArray1OfDatumReference) aGeometricToleranceWithDatumReference_DatumSystem;
+ Handle(StepDimTol_HArray1OfDatumSystemOrReference) aGeometricToleranceWithDatumReference_DatumSystem;
Standard_Integer sub5 = 0;
if ( data->ReadSubList (num, 5, "geometric_tolerance_with_datum_reference.datum_system", ach, sub5) ) {
Standard_Integer nb0 = data->NbParams(sub5);
- aGeometricToleranceWithDatumReference_DatumSystem = new StepDimTol_HArray1OfDatumReference (1, nb0);
+ aGeometricToleranceWithDatumReference_DatumSystem = new StepDimTol_HArray1OfDatumSystemOrReference (1, nb0);
Standard_Integer num2 = sub5;
for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
- Handle(StepDimTol_DatumReference) anIt0;
- data->ReadEntity (num2, i0, "datum_reference", ach, STANDARD_TYPE(StepDimTol_DatumReference), anIt0);
+ StepDimTol_DatumSystemOrReference anIt0;
+ data->ReadEntity (num2, i0, "datum_system_or_reference", ach, anIt0);
aGeometricToleranceWithDatumReference_DatumSystem->SetValue(i0, anIt0);
}
}
SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
- SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
// Inherited fields of GeometricToleranceWithDatumReference
SW.OpenSub();
- for (Standard_Integer i4=1; i4 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Length(); i4++ ) {
- Handle(StepDimTol_DatumReference) Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Value(i4);
- SW.Send (Var0);
+ for (Standard_Integer i4=1; i4 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Length(); i4++ ) {
+ StepDimTol_DatumSystemOrReference Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Value(i4);
+ SW.Send (Var0.Value());
}
SW.CloseSub();
}
iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
- iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
// Inherited fields of GeometricToleranceWithDatumReference
- for (Standard_Integer i3=1; i3 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Length(); i3++ ) {
- Handle(StepDimTol_DatumReference) Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Value(i3);
- iter.AddItem (Var0);
+ for (Standard_Integer i3=1; i3 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Length(); i3++ ) {
+ StepDimTol_DatumSystemOrReference Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Value(i3);
+ iter.AddItem (Var0.Value());
}
}
#include <StepData_StepWriter.hxx>
#include <StepDimTol_CoaxialityTolerance.hxx>
#include <StepDimTol_DatumReference.hxx>
-#include <StepDimTol_HArray1OfDatumReference.hxx>
-#include <StepRepr_ShapeAspect.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
+#include <StepDimTol_HArray1OfDatumSystemOrReference.hxx>
//=======================================================================
//function : RWStepDimTol_RWCoaxialityTolerance
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
- Handle(StepRepr_ShapeAspect) aGeometricTolerance_TolerancedShapeAspect;
- data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, STANDARD_TYPE(StepRepr_ShapeAspect), aGeometricTolerance_TolerancedShapeAspect);
+ StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
+ data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
// Inherited fields of GeometricToleranceWithDatumReference
- Handle(StepDimTol_HArray1OfDatumReference) aGeometricToleranceWithDatumReference_DatumSystem;
+ Handle(StepDimTol_HArray1OfDatumSystemOrReference) aGeometricToleranceWithDatumReference_DatumSystem;
Standard_Integer sub5 = 0;
if ( data->ReadSubList (num, 5, "geometric_tolerance_with_datum_reference.datum_system", ach, sub5) ) {
Standard_Integer nb0 = data->NbParams(sub5);
- aGeometricToleranceWithDatumReference_DatumSystem = new StepDimTol_HArray1OfDatumReference (1, nb0);
+ aGeometricToleranceWithDatumReference_DatumSystem = new StepDimTol_HArray1OfDatumSystemOrReference (1, nb0);
Standard_Integer num2 = sub5;
for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
- Handle(StepDimTol_DatumReference) anIt0;
- data->ReadEntity (num2, i0, "datum_reference", ach, STANDARD_TYPE(StepDimTol_DatumReference), anIt0);
+ StepDimTol_DatumSystemOrReference anIt0;
+ data->ReadEntity (num2, i0, "datum_system_or_reference", ach, anIt0);
aGeometricToleranceWithDatumReference_DatumSystem->SetValue(i0, anIt0);
}
}
SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
- SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
// Inherited fields of GeometricToleranceWithDatumReference
SW.OpenSub();
- for (Standard_Integer i4=1; i4 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Length(); i4++ ) {
- Handle(StepDimTol_DatumReference) Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Value(i4);
- SW.Send (Var0);
+ for (Standard_Integer i4=1; i4 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Length(); i4++ ) {
+ StepDimTol_DatumSystemOrReference Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Value(i4);
+ SW.Send (Var0.Value());
}
SW.CloseSub();
}
iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
- iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
// Inherited fields of GeometricToleranceWithDatumReference
- for (Standard_Integer i3=1; i3 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Length(); i3++ ) {
- Handle(StepDimTol_DatumReference) Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Value(i3);
- iter.AddItem (Var0);
+ for (Standard_Integer i3=1; i3 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Length(); i3++ ) {
+ StepDimTol_DatumSystemOrReference Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Value(i3);
+ iter.AddItem (Var0.Value());
}
}
#include <StepData_StepWriter.hxx>
#include <StepDimTol_ConcentricityTolerance.hxx>
#include <StepDimTol_DatumReference.hxx>
-#include <StepDimTol_HArray1OfDatumReference.hxx>
-#include <StepRepr_ShapeAspect.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
+#include <StepDimTol_HArray1OfDatumSystemOrReference.hxx>
//=======================================================================
//function : RWStepDimTol_RWConcentricityTolerance
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
- Handle(StepRepr_ShapeAspect) aGeometricTolerance_TolerancedShapeAspect;
- data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, STANDARD_TYPE(StepRepr_ShapeAspect), aGeometricTolerance_TolerancedShapeAspect);
+ StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
+ data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
// Inherited fields of GeometricToleranceWithDatumReference
- Handle(StepDimTol_HArray1OfDatumReference) aGeometricToleranceWithDatumReference_DatumSystem;
+ Handle(StepDimTol_HArray1OfDatumSystemOrReference) aGeometricToleranceWithDatumReference_DatumSystem;
Standard_Integer sub5 = 0;
if ( data->ReadSubList (num, 5, "geometric_tolerance_with_datum_reference.datum_system", ach, sub5) ) {
Standard_Integer nb0 = data->NbParams(sub5);
- aGeometricToleranceWithDatumReference_DatumSystem = new StepDimTol_HArray1OfDatumReference (1, nb0);
+ aGeometricToleranceWithDatumReference_DatumSystem = new StepDimTol_HArray1OfDatumSystemOrReference (1, nb0);
Standard_Integer num2 = sub5;
for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
- Handle(StepDimTol_DatumReference) anIt0;
- data->ReadEntity (num2, i0, "datum_reference", ach, STANDARD_TYPE(StepDimTol_DatumReference), anIt0);
+ StepDimTol_DatumSystemOrReference anIt0;
+ data->ReadEntity (num2, i0, "datum_system_or_reference", ach, anIt0);
aGeometricToleranceWithDatumReference_DatumSystem->SetValue(i0, anIt0);
}
}
SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
- SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
// Inherited fields of GeometricToleranceWithDatumReference
SW.OpenSub();
- for (Standard_Integer i4=1; i4 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Length(); i4++ ) {
- Handle(StepDimTol_DatumReference) Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Value(i4);
- SW.Send (Var0);
+ for (Standard_Integer i4=1; i4 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Length(); i4++ ) {
+ StepDimTol_DatumSystemOrReference Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Value(i4);
+ SW.Send (Var0.Value());
}
SW.CloseSub();
}
iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
- iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
// Inherited fields of GeometricToleranceWithDatumReference
- for (Standard_Integer i3=1; i3 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Length(); i3++ ) {
- Handle(StepDimTol_DatumReference) Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Value(i3);
- iter.AddItem (Var0);
+ for (Standard_Integer i3=1; i3 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Length(); i3++ ) {
+ StepDimTol_DatumSystemOrReference Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Value(i3);
+ iter.AddItem (Var0.Value());
}
}
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_CylindricityTolerance.hxx>
-#include <StepRepr_ShapeAspect.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
//=======================================================================
//function : RWStepDimTol_RWCylindricityTolerance
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
- Handle(StepRepr_ShapeAspect) aGeometricTolerance_TolerancedShapeAspect;
- data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, STANDARD_TYPE(StepRepr_ShapeAspect), aGeometricTolerance_TolerancedShapeAspect);
+ StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
+ data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
// Initialize entity
ent->Init(aGeometricTolerance_Name,
SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
- SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
}
//=======================================================================
iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
- iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
}
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepDimTol_RWDatumReferenceCompartment.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepDimTol_Datum.hxx>
+#include <StepDimTol_DatumReferenceCompartment.hxx>
+#include <StepDimTol_GeneralDatumReference.hxx>
+#include <StepDimTol_HArray1OfDatumReferenceElement.hxx>
+#include <StepRepr_ProductDefinitionShape.hxx>
+
+//=======================================================================
+//function : RWStepDimTol_RWDatumReferenceCompartment
+//purpose :
+//=======================================================================
+
+RWStepDimTol_RWDatumReferenceCompartment::RWStepDimTol_RWDatumReferenceCompartment ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWDatumReferenceCompartment::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepDimTol_DatumReferenceCompartment) &ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,6,ach,"datum_reference_element") ) return;
+
+ // Inherited fields of ShapeAspect
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Name;
+ data->ReadString (num, 1, "shape_aspect.name", ach, aShapeAspect_Name);
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Description;
+ if ( data->IsParamDefined (num,2) ) {
+ data->ReadString (num, 2, "shape_aspect.description", ach, aShapeAspect_Description);
+ }
+
+ Handle(StepRepr_ProductDefinitionShape) aShapeAspect_OfShape;
+ data->ReadEntity (num, 3, "shape_aspect.of_shape", ach, STANDARD_TYPE(StepRepr_ProductDefinitionShape), aShapeAspect_OfShape);
+
+ StepData_Logical aShapeAspect_ProductDefinitional;
+ data->ReadLogical (num, 4, "shape_aspect.product_definitional", ach, aShapeAspect_ProductDefinitional);
+
+ // Inherited fields from GeneralDatumReference
+
+ StepDimTol_DatumOrCommonDatum aBase;
+ Handle(StepDimTol_Datum) aDatum;
+ Interface_ParamType aType = data->ParamType(num, 5);
+ if (aType == Interface_ParamIdent) {
+ data->ReadEntity(num, 5, "general_datum_reference.base", ach, STANDARD_TYPE(StepDimTol_Datum), aDatum);
+ aBase.SetValue(aDatum);
+ }
+ else {
+ Handle(StepDimTol_HArray1OfDatumReferenceElement) anItems;
+ Handle(StepDimTol_DatumReferenceElement) anEnt;
+ Standard_Integer nbSub;
+ if (data->ReadSubList (num,5,"general_datum_reference.base",ach,nbSub)) {
+ aType = data->ParamType(nbSub, 1);
+ if (aType == Interface_ParamSub) {
+ Standard_Integer aNewNbSub;
+ if (data->ReadSubList (nbSub,1,"general_datum_reference.base",ach,aNewNbSub)) {
+ nbSub = aNewNbSub;
+ }
+ }
+ Standard_Integer nbElements = data->NbParams(nbSub);
+ anItems = new StepDimTol_HArray1OfDatumReferenceElement (1, nbElements);
+ for (Standard_Integer i = 1; i <= nbElements; i++) {
+ if (data->ReadEntity(nbSub, i,"datum_reference_element", ach, STANDARD_TYPE(StepDimTol_DatumReferenceElement), anEnt))
+ anItems->SetValue(i, anEnt);
+ }
+ }
+ aBase.SetValue(anItems);
+ }
+
+ Standard_Integer nbSub;
+ Standard_Boolean hasModifiers = data->ReadSubList(num, 6, "general_datum_reference.modifiers", ach, nbSub, Standard_True);
+ Handle(StepDimTol_HArray1OfDatumReferenceModifier) aModifiers;
+ if (hasModifiers) {
+ StepDimTol_DatumReferenceModifier anEnt;
+ Standard_Integer nbElements = data->NbParams(nbSub);
+ aModifiers = new StepDimTol_HArray1OfDatumReferenceModifier (1, nbElements);
+ for (Standard_Integer i = 1; i <= nbElements; i++) {
+ Interface_ParamType aType = data->ParamType (nbSub, i);
+ if (aType == Interface_ParamIdent) {
+ Handle(StepDimTol_DatumReferenceModifierWithValue) aDRMWV;
+ data->ReadEntity(nbSub, i,"datum_reference_modifier_with_value", ach, STANDARD_TYPE(StepDimTol_DatumReferenceModifierWithValue), aDRMWV);
+ anEnt.SetValue(aDRMWV);
+ }
+ else {
+ Handle(StepData_SelectMember) aMember;
+ data->ReadMember(nbSub, i, "simple_datum_reference_modifier", ach, aMember);
+ Standard_CString anEnumText = aMember->EnumText();
+ Handle(StepDimTol_SimpleDatumReferenceModifierMember) aSDRM = new StepDimTol_SimpleDatumReferenceModifierMember();
+ aSDRM->SetEnumText(0, anEnumText);
+ anEnt.SetValue(aSDRM);
+ }
+ aModifiers->SetValue(i, anEnt);
+ }
+ }
+
+ // Initialize entity
+ ent->Init(aShapeAspect_Name,
+ aShapeAspect_Description,
+ aShapeAspect_OfShape,
+ aShapeAspect_ProductDefinitional,
+ aBase,
+ hasModifiers,
+ aModifiers);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWDatumReferenceCompartment::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepDimTol_DatumReferenceCompartment) &ent) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ SW.Send (ent->Name());
+
+ SW.Send (ent->Description());
+
+ SW.Send (ent->OfShape());
+
+ SW.SendLogical (ent->ProductDefinitional());
+
+ // Inherited fields from GeneralDatumReference
+ Standard_Integer aBaseType = ent->Base().CaseNum(ent->Base().Value());
+ if (aBaseType == 1) {
+ SW.Send(ent->Base().Datum());
+ }
+ else if (aBaseType == 2) {
+ Handle(StepDimTol_HArray1OfDatumReferenceElement) anArray = ent->Base().CommonDatumList();
+ Standard_Integer i, nb = (anArray.IsNull() ? 0 : anArray->Length());
+ SW.OpenSub();
+ for (i = 1; i <= nb; i++)
+ SW.Send (anArray->Value(i));
+ SW.CloseSub();
+ }
+
+ if (ent->HasModifiers()) {
+ Standard_Integer i, nb = ent->NbModifiers();
+ SW.OpenSub();
+ for (i = 1; i <= nb; i++) {
+ StepDimTol_DatumReferenceModifier aModifier = ent->ModifiersValue(i);
+ Standard_Integer aType = aModifier.CaseNum(aModifier.Value());
+ switch (aType) {
+ case 1: SW.Send(aModifier.DatumReferenceModifierWithValue()); break;
+ case 2: SW.SendEnum(aModifier.SimpleDatumReferenceModifierMember()->EnumText());break;
+ }
+ }
+ SW.CloseSub();
+ }
+
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWDatumReferenceCompartment::Share (const Handle(StepDimTol_DatumReferenceCompartment) &ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ iter.AddItem (ent->OfShape());
+
+ // Inherited fields from GeneralDatumReference
+ Standard_Integer aBaseType = ent->Base().CaseNum(ent->Base().Value());
+ if (aBaseType == 1) {
+ iter.AddItem(ent->Base().Datum());
+ }
+ else if (aBaseType == 2) {
+ Handle(StepDimTol_HArray1OfDatumReferenceElement) anArray = ent->Base().CommonDatumList();
+ Standard_Integer i, nb = (anArray.IsNull() ? 0 : anArray->Length());
+ for (i = 1; i <= nb; i++)
+ iter.AddItem (anArray->Value(i));
+ }
+}
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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 _RWStepDimTol_RWDatumReferenceCompartment_HeaderFile
+#define _RWStepDimTol_RWDatumReferenceCompartment_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepDimTol_DatumReferenceCompartment;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write tool for DatumReferenceElement
+class RWStepDimTol_RWDatumReferenceCompartment
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ //! Empty constructor
+ Standard_EXPORT RWStepDimTol_RWDatumReferenceCompartment();
+
+ //! Reads DatumReferenceElement
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepDimTol_DatumReferenceCompartment)& ent) const;
+
+ //! Writes DatumReferenceElement
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepDimTol_DatumReferenceCompartment)& ent) const;
+
+ //! Fills data for graph (shared items)
+ Standard_EXPORT void Share (const Handle(StepDimTol_DatumReferenceCompartment)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepDimTol_RWDatumReferenceCompartment_HeaderFile
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepDimTol_RWDatumReferenceElement.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepDimTol_Datum.hxx>
+#include <StepDimTol_DatumReferenceElement.hxx>
+#include <StepDimTol_DatumReferenceModifier.hxx>
+#include <StepDimTol_GeneralDatumReference.hxx>
+#include <StepDimTol_HArray1OfDatumReferenceElement.hxx>
+#include <StepDimTol_HArray1OfDatumReferenceModifier.hxx>
+#include <StepRepr_ProductDefinitionShape.hxx>
+
+//=======================================================================
+//function : RWStepDimTol_RWDatumReferenceElement
+//purpose :
+//=======================================================================
+
+RWStepDimTol_RWDatumReferenceElement::RWStepDimTol_RWDatumReferenceElement ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWDatumReferenceElement::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepDimTol_DatumReferenceElement) &ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,6,ach,"datum_reference_element") ) return;
+
+ // Inherited fields of ShapeAspect
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Name;
+ data->ReadString (num, 1, "shape_aspect.name", ach, aShapeAspect_Name);
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Description;
+ if ( data->IsParamDefined (num,2) ) {
+ data->ReadString (num, 2, "shape_aspect.description", ach, aShapeAspect_Description);
+ }
+
+ Handle(StepRepr_ProductDefinitionShape) aShapeAspect_OfShape;
+ data->ReadEntity (num, 3, "shape_aspect.of_shape", ach, STANDARD_TYPE(StepRepr_ProductDefinitionShape), aShapeAspect_OfShape);
+
+ StepData_Logical aShapeAspect_ProductDefinitional;
+ data->ReadLogical (num, 4, "shape_aspect.product_definitional", ach, aShapeAspect_ProductDefinitional);
+
+ // Inherited fields from GeneralDatumReference
+
+ StepDimTol_DatumOrCommonDatum aBase;
+ Handle(StepDimTol_Datum) aDatum;
+ Interface_ParamType aType = data->ParamType(num, 5);
+ if (aType == Interface_ParamIdent) {
+ data->ReadEntity(num, 5, "general_datum_reference.base", ach, STANDARD_TYPE(StepDimTol_Datum), aDatum);
+ aBase.SetValue(aDatum);
+ }
+ else {
+ Handle(StepDimTol_HArray1OfDatumReferenceElement) anItems;
+ Handle(StepDimTol_DatumReferenceElement) anEnt;
+ Standard_Integer nbSub;
+ if (data->ReadSubList (num,5,"general_datum_reference.base",ach,nbSub)) {
+ aType = data->ParamType(nbSub, 1);
+ if (aType == Interface_ParamSub) {
+ Standard_Integer aNewNbSub;
+ if (data->ReadSubList (nbSub,1,"general_datum_reference.base",ach,aNewNbSub)) {
+ nbSub = aNewNbSub;
+ }
+ }
+ Standard_Integer nbElements = data->NbParams(nbSub);
+ anItems = new StepDimTol_HArray1OfDatumReferenceElement (1, nbElements);
+ for (Standard_Integer i = 1; i <= nbElements; i++) {
+ if (data->ReadEntity(nbSub, i,"datum_reference_element", ach, STANDARD_TYPE(StepDimTol_DatumReferenceElement), anEnt))
+ anItems->SetValue(i, anEnt);
+ }
+ }
+ aBase.SetValue(anItems);
+ }
+
+ Standard_Integer nbSub;
+ Standard_Boolean hasModifiers = data->ReadSubList(num, 6, "general_datum_reference.modifiers", ach, nbSub, Standard_True);
+ Handle(StepDimTol_HArray1OfDatumReferenceModifier) aModifiers;
+ if (hasModifiers) {
+ StepDimTol_DatumReferenceModifier anEnt;
+ Standard_Integer nbElements = data->NbParams(nbSub);
+ aModifiers = new StepDimTol_HArray1OfDatumReferenceModifier (1, nbElements);
+ for (Standard_Integer i = 1; i <= nbElements; i++) {
+ Interface_ParamType aType = data->ParamType (nbSub, i);
+ if (aType == Interface_ParamIdent) {
+ Handle(StepDimTol_DatumReferenceModifierWithValue) aDRMWV;
+ data->ReadEntity(nbSub, i,"datum_reference_modifier_with_value", ach, STANDARD_TYPE(StepDimTol_DatumReferenceModifierWithValue), aDRMWV);
+ anEnt.SetValue(aDRMWV);
+ }
+ else {
+ Handle(StepData_SelectMember) aMember;
+ data->ReadMember(nbSub, i, "simple_datum_reference_modifier", ach, aMember);
+ Standard_CString anEnumText = aMember->EnumText();
+ Handle(StepDimTol_SimpleDatumReferenceModifierMember) aSDRM = new StepDimTol_SimpleDatumReferenceModifierMember();
+ aSDRM->SetEnumText(0, anEnumText);
+ anEnt.SetValue(aSDRM);
+ }
+ aModifiers->SetValue(i, anEnt);
+ }
+ }
+
+ // Initialize entity
+ ent->Init(aShapeAspect_Name,
+ aShapeAspect_Description,
+ aShapeAspect_OfShape,
+ aShapeAspect_ProductDefinitional,
+ aBase,
+ hasModifiers,
+ aModifiers);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWDatumReferenceElement::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepDimTol_DatumReferenceElement) &ent) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ SW.Send (ent->Name());
+
+ SW.Send (ent->Description());
+
+ SW.Send (ent->OfShape());
+
+ SW.SendLogical (ent->ProductDefinitional());
+
+ // Inherited fields from GeneralDatumReference
+ Standard_Integer aBaseType = ent->Base().CaseNum(ent->Base().Value());
+ if (aBaseType == 1) {
+ SW.Send(ent->Base().Datum());
+ }
+ else if (aBaseType == 2) {
+ Handle(StepDimTol_HArray1OfDatumReferenceElement) anArray = (ent->Base()).CommonDatumList();
+ Standard_Integer i, nb = (anArray.IsNull() ? 0 : anArray->Length());
+ SW.OpenSub();
+ for (i = 1; i <= nb; i++)
+ SW.Send (anArray->Value(i));
+ SW.CloseSub();
+ }
+
+ if (ent->HasModifiers()) {
+ Standard_Integer i, nb = ent->NbModifiers();
+ SW.OpenSub();
+ for (i = 1; i <= nb; i++) {
+ StepDimTol_DatumReferenceModifier aModifier = ent->ModifiersValue(i);
+ Standard_Integer aType = aModifier.CaseNum(aModifier.Value());
+ switch (aType) {
+ case 1: SW.Send(aModifier.DatumReferenceModifierWithValue()); break;
+ case 2: SW.SendEnum(aModifier.SimpleDatumReferenceModifierMember()->EnumText());break;
+ }
+ }
+ SW.CloseSub();
+ }
+
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWDatumReferenceElement::Share (const Handle(StepDimTol_DatumReferenceElement) &ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ iter.AddItem (ent->OfShape());
+
+ // Inherited fields from GeneralDatumReference
+ Standard_Integer aBaseType = ent->Base().CaseNum(ent->Base().Value());
+ if (aBaseType == 1) {
+ iter.AddItem(ent->Base().Datum());
+ }
+ else if (aBaseType == 2) {
+ Handle(StepDimTol_HArray1OfDatumReferenceElement) anArray = ent->Base().CommonDatumList();
+ Standard_Integer i, nb = (anArray.IsNull() ? 0 : anArray->Length());
+ for (i = 1; i <= nb; i++)
+ iter.AddItem (anArray->Value(i));
+ }
+}
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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 _RWStepDimTol_RWDatumReferenceElement_HeaderFile
+#define _RWStepDimTol_RWDatumReferenceElement_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepDimTol_DatumReferenceElement;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write tool for DatumReferenceElement
+class RWStepDimTol_RWDatumReferenceElement
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ //! Empty constructor
+ Standard_EXPORT RWStepDimTol_RWDatumReferenceElement();
+
+ //! Reads DatumReferenceElement
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepDimTol_DatumReferenceElement)& ent) const;
+
+ //! Writes DatumReferenceElement
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepDimTol_DatumReferenceElement)& ent) const;
+
+ //! Fills data for graph (shared items)
+ Standard_EXPORT void Share (const Handle(StepDimTol_DatumReferenceElement)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepDimTol_RWDatumReferenceElement_HeaderFile
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepDimTol_RWDatumReferenceModifierWithValue.hxx>
+
+#include <Interface_Check.hxx>
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepBasic_LengthMeasureWithUnit.hxx>
+#include <StepDimTol_DatumReferenceModifierType.hxx>
+#include <StepDimTol_DatumReferenceModifierWithValue.hxx>
+
+//=======================================================================
+//function : RWStepDimTol_RWGeometricTolerance
+//purpose :
+//=======================================================================
+
+RWStepDimTol_RWDatumReferenceModifierWithValue::RWStepDimTol_RWDatumReferenceModifierWithValue ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWDatumReferenceModifierWithValue::
+ ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepDimTol_DatumReferenceModifierWithValue) &ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num, 2, ach, "datum_reference_modifier_with_value") ) return;
+
+ // own fields of DatumReferenceModifierWithValue
+
+ StepDimTol_DatumReferenceModifierType aModifierType = StepDimTol_CircularOrCylindrical;
+ if (data->ParamType (num, 1) == Interface_ParamEnum) {
+ Standard_CString text = data->ParamCValue(num, 1);
+ if (strcmp(text, ".CIRCULAR_OR_CYLINDRICAL.")==0) aModifierType = StepDimTol_CircularOrCylindrical;
+ else if (strcmp(text, ".DISTANCE.")==0) aModifierType = StepDimTol_Distance;
+ else if (strcmp(text, ".PROJECTED.")==0) aModifierType = StepDimTol_Projected;
+ else if (strcmp(text, ".SPHERICAL.")==0) aModifierType = StepDimTol_Spherical;
+ else ach->AddFail("Parameter #1 (modifier_type) has not allowed value");
+ }
+ else ach->AddFail("Parameter #1 (modifier_type) is not an enumeration");
+
+ Handle(StepBasic_LengthMeasureWithUnit) aModifierValue;
+ data->ReadEntity (num, 2, "modifier_value", ach, STANDARD_TYPE(StepBasic_LengthMeasureWithUnit), aModifierValue);
+
+ // Initialize entity
+ ent->Init(aModifierType,
+ aModifierValue);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWDatumReferenceModifierWithValue::
+ WriteStep (StepData_StepWriter& SW,
+ const Handle(StepDimTol_DatumReferenceModifierWithValue) &ent) const
+{
+ // own fields of DatumReferenceModifierWithValue
+
+ switch (ent->ModifierType()) {
+ case StepDimTol_CircularOrCylindrical: SW.SendEnum (".CIRCULAR_OR_CYLINDRICAL."); break;
+ case StepDimTol_Distance: SW.SendEnum (".DISTANCE."); break;
+ case StepDimTol_Projected: SW.SendEnum (".PROJECTED."); break;
+ case StepDimTol_Spherical: SW.SendEnum (".SPHERICAL."); break;
+ }
+
+ SW.Send (ent->ModifierValue());
+}
--- /dev/null
+// Created on: 2015-07-07
+// Created by: Irina KRYLOVA
+// 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 _RWStepDimTol_RWDatumReferenceModifierWithValue_HeaderFile
+#define _RWStepDimTol_RWDatumReferenceModifierWithValue_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepDimTol_DatumReferenceModifierWithValue;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write tool for DatumReferenceModifierWithValue
+class RWStepDimTol_RWDatumReferenceModifierWithValue
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ //! Empty constructor
+ Standard_EXPORT RWStepDimTol_RWDatumReferenceModifierWithValue();
+
+ //! Reads DatumReferenceModifierWithValue
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepDimTol_DatumReferenceModifierWithValue)& ent) const;
+
+ //! Writes DatumReferenceModifierWithValue
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepDimTol_DatumReferenceModifierWithValue)& ent) const;
+};
+#endif // _RWStepDimTol_RWDatumReferenceModifierWithValue_HeaderFile
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepDimTol_RWDatumSystem.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepDimTol_DatumReferenceCompartment.hxx>
+#include <StepDimTol_DatumSystem.hxx>
+#include <StepRepr_ProductDefinitionShape.hxx>
+
+//=======================================================================
+//function : RWStepDimTol_RWDatumSystem
+//purpose :
+//=======================================================================
+
+RWStepDimTol_RWDatumSystem::RWStepDimTol_RWDatumSystem ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWDatumSystem::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepDimTol_DatumSystem) &ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,5,ach,"datum_system") ) return;
+
+ // Inherited fields of ShapeAspect
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Name;
+ data->ReadString (num, 1, "shape_aspect.name", ach, aShapeAspect_Name);
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Description;
+ if ( data->IsParamDefined (num,2) ) {
+ data->ReadString (num, 2, "shape_aspect.description", ach, aShapeAspect_Description);
+ }
+
+ Handle(StepRepr_ProductDefinitionShape) aShapeAspect_OfShape;
+ data->ReadEntity (num, 3, "shape_aspect.of_shape", ach, STANDARD_TYPE(StepRepr_ProductDefinitionShape), aShapeAspect_OfShape);
+
+ StepData_Logical aShapeAspect_ProductDefinitional;
+ data->ReadLogical (num, 4, "shape_aspect.product_definitional", ach, aShapeAspect_ProductDefinitional);
+
+ // Own fields of DatumSystem
+
+ Handle(StepDimTol_HArray1OfDatumReferenceCompartment) aConstituents;
+ Handle(StepDimTol_DatumReferenceCompartment) anEnt;
+ Standard_Integer nbSub;
+ if (data->ReadSubList (num,5,"base",ach,nbSub)) {
+ Standard_Integer nbElements = data->NbParams(nbSub);
+ aConstituents = new StepDimTol_HArray1OfDatumReferenceCompartment (1, nbElements);
+ for (Standard_Integer i = 1; i <= nbElements; i++) {
+ if (data->ReadEntity(nbSub, i,"datum_reference_compartment", ach, STANDARD_TYPE(StepDimTol_DatumReferenceCompartment), anEnt))
+ aConstituents->SetValue(i, anEnt);
+ }
+ }
+
+ // Initialize entity
+ ent->Init(aShapeAspect_Name,
+ aShapeAspect_Description,
+ aShapeAspect_OfShape,
+ aShapeAspect_ProductDefinitional,
+ aConstituents);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWDatumSystem::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepDimTol_DatumSystem) &ent) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ SW.Send (ent->Name());
+
+ SW.Send (ent->Description());
+
+ SW.Send (ent->OfShape());
+
+ SW.SendLogical (ent->ProductDefinitional());
+
+ // Own fields of DatumSystem
+ Standard_Integer i, nb = ent->NbConstituents();
+ SW.OpenSub();
+ for (i = 1; i <= nb; i++)
+ SW.Send (ent->ConstituentsValue(i));
+ SW.CloseSub();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWDatumSystem::Share (const Handle(StepDimTol_DatumSystem) &ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ iter.AddItem (ent->OfShape());
+
+ // Own fields of DatumSystem
+ Standard_Integer i, nb = ent->NbConstituents();
+ for (i = 1; i <= nb; i++)
+ iter.AddItem (ent->ConstituentsValue(i));
+}
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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 _RWStepDimTol_RWDatumSystem_HeaderFile
+#define _RWStepDimTol_RWDatumSystem_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepDimTol_DatumSystem;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write tool for DatumSystem
+class RWStepDimTol_RWDatumSystem
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ //! Empty constructor
+ Standard_EXPORT RWStepDimTol_RWDatumSystem();
+
+ //! Reads DatumSystem
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepDimTol_DatumSystem)& ent) const;
+
+ //! Writes DatumSystem
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepDimTol_DatumSystem)& ent) const;
+
+ //! Fills data for graph (shared items)
+ Standard_EXPORT void Share (const Handle(StepDimTol_DatumSystem)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepDimTol_RWDatumSystem_HeaderFile
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_FlatnessTolerance.hxx>
-#include <StepRepr_ShapeAspect.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
//=======================================================================
//function : RWStepDimTol_RWFlatnessTolerance
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
- Handle(StepRepr_ShapeAspect) aGeometricTolerance_TolerancedShapeAspect;
- data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, STANDARD_TYPE(StepRepr_ShapeAspect), aGeometricTolerance_TolerancedShapeAspect);
+ StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
+ data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
// Initialize entity
ent->Init(aGeometricTolerance_Name,
SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
- SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
}
//=======================================================================
iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
- iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
}
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepDimTol_RWGeneralDatumReference.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepDimTol_Datum.hxx>
+#include <StepDimTol_DatumReferenceModifier.hxx>
+#include <StepDimTol_GeneralDatumReference.hxx>
+#include <StepDimTol_HArray1OfDatumReferenceElement.hxx>
+#include <StepRepr_ProductDefinitionShape.hxx>
+
+//=======================================================================
+//function : RWStepDimTol_RWGeneralDatumReference
+//purpose :
+//=======================================================================
+
+RWStepDimTol_RWGeneralDatumReference::RWStepDimTol_RWGeneralDatumReference ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWGeneralDatumReference::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepDimTol_GeneralDatumReference) &ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,6,ach,"general_datum_reference") ) return;
+
+ // Inherited fields of ShapeAspect
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Name;
+ data->ReadString (num, 1, "shape_aspect.name", ach, aShapeAspect_Name);
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Description;
+ if ( data->IsParamDefined (num,2) ) {
+ data->ReadString (num, 2, "shape_aspect.description", ach, aShapeAspect_Description);
+ }
+
+ Handle(StepRepr_ProductDefinitionShape) aShapeAspect_OfShape;
+ data->ReadEntity (num, 3, "shape_aspect.of_shape", ach, STANDARD_TYPE(StepRepr_ProductDefinitionShape), aShapeAspect_OfShape);
+
+ StepData_Logical aShapeAspect_ProductDefinitional;
+ data->ReadLogical (num, 4, "shape_aspect.product_definitional", ach, aShapeAspect_ProductDefinitional);
+
+ // Own fields of GeneralDatumReference
+
+ StepDimTol_DatumOrCommonDatum aBase;
+ Handle(StepDimTol_Datum) aDatum;
+ Interface_ParamType aType = data->ParamType(num, 5);
+ if (aType == Interface_ParamIdent) {
+ data->ReadEntity(num, 5, "general_datum_reference.base", ach, STANDARD_TYPE(StepDimTol_Datum), aDatum);
+ aBase.SetValue(aDatum);
+ }
+ else {
+ Handle(StepDimTol_HArray1OfDatumReferenceElement) anItems;
+ Handle(StepDimTol_DatumReferenceElement) anEnt;
+ Standard_Integer nbSub;
+ if (data->ReadSubList (num,5,"general_datum_reference.base",ach,nbSub)) {
+ aType = data->ParamType(nbSub, 1);
+ if (aType == Interface_ParamSub) {
+ Standard_Integer aNewNbSub;
+ if (data->ReadSubList (nbSub,1,"general_datum_reference.base",ach,aNewNbSub)) {
+ nbSub = aNewNbSub;
+ }
+ }
+ Standard_Integer nbElements = data->NbParams(nbSub);
+ anItems = new StepDimTol_HArray1OfDatumReferenceElement (1, nbElements);
+ for (Standard_Integer i = 1; i <= nbElements; i++) {
+ if (data->ReadEntity(nbSub, i,"datum_reference_element", ach, STANDARD_TYPE(StepDimTol_DatumReferenceElement), anEnt))
+ anItems->SetValue(i, anEnt);
+ }
+ }
+ aBase.SetValue(anItems);
+ }
+
+ Standard_Integer nbSub;
+ Standard_Boolean hasModifiers = data->ReadSubList(num, 6, "general_datum_reference.modifiers", ach, nbSub, Standard_True);
+ Handle(StepDimTol_HArray1OfDatumReferenceModifier) aModifiers;
+ if (hasModifiers) {
+ StepDimTol_DatumReferenceModifier anEnt;
+ Standard_Integer nbElements = data->NbParams(nbSub);
+ aModifiers = new StepDimTol_HArray1OfDatumReferenceModifier (1, nbElements);
+ for (Standard_Integer i = 1; i <= nbElements; i++) {
+ Interface_ParamType aType = data->ParamType (nbSub, i);
+ if (aType == Interface_ParamIdent) {
+ Handle(StepDimTol_DatumReferenceModifierWithValue) aDRMWV;
+ data->ReadEntity(nbSub, i,"datum_reference_modifier_with_value", ach, STANDARD_TYPE(StepDimTol_DatumReferenceModifierWithValue), aDRMWV);
+ anEnt.SetValue(aDRMWV);
+ }
+ else {
+ Handle(StepData_SelectMember) aMember;
+ data->ReadMember(nbSub, i, "simple_datum_reference_modifier", ach, aMember);
+ Standard_CString anEnumText = aMember->EnumText();
+ Handle(StepDimTol_SimpleDatumReferenceModifierMember) aSDRM = new StepDimTol_SimpleDatumReferenceModifierMember();
+ aSDRM->SetEnumText(0, anEnumText);
+ anEnt.SetValue(aSDRM);
+ }
+ aModifiers->SetValue(i, anEnt);
+ }
+ }
+
+ // Initialize entity
+ ent->Init(aShapeAspect_Name,
+ aShapeAspect_Description,
+ aShapeAspect_OfShape,
+ aShapeAspect_ProductDefinitional,
+ aBase,
+ hasModifiers,
+ aModifiers);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWGeneralDatumReference::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepDimTol_GeneralDatumReference) &ent) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ SW.Send (ent->Name());
+
+ SW.Send (ent->Description());
+
+ SW.Send (ent->OfShape());
+
+ SW.SendLogical (ent->ProductDefinitional());
+
+ // Own fields of GeneralDatumReference
+ Standard_Integer aBaseType = ent->Base().CaseNum(ent->Base().Value());
+ if (aBaseType == 1) {
+ SW.Send(ent->Base().Datum());
+ }
+ else if (aBaseType == 2) {
+ Handle(StepDimTol_HArray1OfDatumReferenceElement) anArray = ent->Base().CommonDatumList();
+ Standard_Integer i, nb = (anArray.IsNull() ? 0 : anArray->Length());
+ SW.OpenSub();
+ for (i = 1; i <= nb; i++)
+ SW.Send (anArray->Value(i));
+ SW.CloseSub();
+ }
+
+ if (ent->HasModifiers()) {
+ Standard_Integer i, nb = ent->NbModifiers();
+ SW.OpenSub();
+ for (i = 1; i <= nb; i++) {
+ StepDimTol_DatumReferenceModifier aModifier = ent->ModifiersValue(i);
+ Standard_Integer aType = aModifier.CaseNum(aModifier.Value());
+ switch (aType) {
+ case 1: SW.Send(aModifier.DatumReferenceModifierWithValue()); break;
+ case 2: SW.SendEnum(aModifier.SimpleDatumReferenceModifierMember()->EnumText());break;
+ }
+ }
+ SW.CloseSub();
+ }
+
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWGeneralDatumReference::Share (const Handle(StepDimTol_GeneralDatumReference) &ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ iter.AddItem (ent->OfShape());
+
+ // Own fields of GeneralDatumReference
+ Standard_Integer aBaseType = ent->Base().CaseNum(ent->Base().Value());
+ if (aBaseType == 1) {
+ iter.AddItem(ent->Base().Datum());
+ }
+ else if (aBaseType == 2) {
+ Handle(StepDimTol_HArray1OfDatumReferenceElement) anArray = ent->Base().CommonDatumList();
+ Standard_Integer i, nb = (anArray.IsNull() ? 0 : anArray->Length());
+ for (i = 1; i <= nb; i++)
+ iter.AddItem (anArray->Value(i));
+ }
+}
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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 _RWStepDimTol_RWGeneralDatumReference_HeaderFile
+#define _RWStepDimTol_RWGeneralDatumReference_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepDimTol_GeneralDatumReference;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write tool for GeneralDatumReference
+class RWStepDimTol_RWGeneralDatumReference
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ //! Empty constructor
+ Standard_EXPORT RWStepDimTol_RWGeneralDatumReference();
+
+ //! Reads GeneralDatumReference
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepDimTol_GeneralDatumReference)& ent) const;
+
+ //! Writes GeneralDatumReference
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepDimTol_GeneralDatumReference)& ent) const;
+
+ //! Fills data for graph (shared items)
+ Standard_EXPORT void Share (const Handle(StepDimTol_GeneralDatumReference)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepDimTol_RWGeneralDatumReference_HeaderFile
--- /dev/null
+// Created on: 2015-08-10
+// Created by: Irina KRYLOVA
+// 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.
+
+
+#include <Interface_Check.hxx>
+#include <Interface_EntityIterator.hxx>
+#include <RWStepDimTol_RWGeoTolAndGeoTolWthDatRef.hxx>
+#include <StepBasic_MeasureWithUnit.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepDimTol_DatumReference.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
+#include <StepDimTol_GeometricToleranceType.hxx>
+#include <StepDimTol_GeometricToleranceWithDatumReference.hxx>
+#include <StepDimTol_GeoTolAndGeoTolWthDatRef.hxx>
+#include <StepDimTol_HArray1OfDatumSystemOrReference.hxx>
+
+//=======================================================================
+//function : RWStepDimTol_RWGeoTolAndGeoTolWthDatRef
+//purpose :
+//=======================================================================
+RWStepDimTol_RWGeoTolAndGeoTolWthDatRef::RWStepDimTol_RWGeoTolAndGeoTolWthDatRef()
+{
+}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWGeoTolAndGeoTolWthDatRef::ReadStep
+ (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num0, Handle(Interface_Check)& ach,
+ const Handle(StepDimTol_GeoTolAndGeoTolWthDatRef)& ent) const
+{
+ Standard_Integer num = 0;//num0;
+ data->NamedForComplex("GEOMETRIC_TOLERANCE",num0,num,ach);
+ if (!data->CheckNbParams(num,4,ach,"geometric_tolerance")) return;
+ // Own fields of GeometricTolerance
+ Handle(TCollection_HAsciiString) aName;
+ data->ReadString (num, 1, "name", ach, aName);
+ Handle(TCollection_HAsciiString) aDescription;
+ data->ReadString (num, 2, "description", ach, aDescription);
+ Handle(StepBasic_MeasureWithUnit) aMagnitude;
+ data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aMagnitude);
+ StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
+ data->ReadEntity (num, 4, "toleranced_shape_aspect", ach, aTolerancedShapeAspect);
+
+ data->NamedForComplex("GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE",num0,num,ach);
+ // Own fields of GeometricToleranceWithDatumReference
+ Handle(StepDimTol_HArray1OfDatumSystemOrReference) aDatumSystem;
+ Standard_Integer sub5 = 0;
+ if ( data->ReadSubList (num, 1, "datum_system", ach, sub5) ) {
+ Standard_Integer nb0 = data->NbParams(sub5);
+ aDatumSystem = new StepDimTol_HArray1OfDatumSystemOrReference (1, nb0);
+ Standard_Integer num2 = sub5;
+ for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
+ StepDimTol_DatumSystemOrReference anIt0;
+ data->ReadEntity (num2, i0, "datum_system_or_reference", ach, anIt0);
+ aDatumSystem->SetValue(i0, anIt0);
+ }
+ }
+ // Initialize entity
+ Handle(StepDimTol_GeometricToleranceWithDatumReference) aGTWDR =
+ new StepDimTol_GeometricToleranceWithDatumReference;
+ aGTWDR->SetDatumSystem(aDatumSystem);
+
+ //Choose type of geometric tolerance
+ TColStd_SequenceOfAsciiString aTypes;
+ data->ComplexType(num0, aTypes);
+ Standard_CString aFirst = aTypes.First().ToCString();
+ Standard_CString aLast = aTypes.Last().ToCString();
+ StepDimTol_GeometricToleranceType aType = StepDimTol_GTTPositionTolerance;
+ if (strcmp(aFirst, "ANGULARITY_TOLERANCE") == 0) aType = StepDimTol_GTTAngularityTolerance;
+ else if (strcmp(aFirst, "CIRCULAR_RUNOUT_TOLERANCE") == 0) aType = StepDimTol_GTTCircularRunoutTolerance;
+ else if (strcmp(aFirst, "COAXIALITY_TOLERANCE") == 0) aType = StepDimTol_GTTCoaxialityTolerance;
+ else if (strcmp(aFirst, "CONCENTRICITY_TOLERANCE") == 0) aType = StepDimTol_GTTConcentricityTolerance;
+ else if (strcmp(aFirst, "CYLINDRICITY_TOLERANCE") == 0) aType = StepDimTol_GTTCylindricityTolerance;
+ else if (strcmp(aFirst, "FLATNESS_TOLERANCE") == 0) aType = StepDimTol_GTTFlatnessTolerance;
+ else if (strcmp(aLast, "LINE_PROFILE_TOLERANCE") == 0) aType = StepDimTol_GTTLineProfileTolerance;
+ else if (strcmp(aLast, "PARALLELISM_TOLERANCE") == 0) aType = StepDimTol_GTTParallelismTolerance;
+ else if (strcmp(aLast, "PERPENDICULARITY_TOLERANCE") == 0) aType = StepDimTol_GTTPerpendicularityTolerance;
+ else if (strcmp(aLast, "POSITION_TOLERANCE") == 0) aType = StepDimTol_GTTPositionTolerance;
+ else if (strcmp(aLast, "ROUNDNESS_TOLERANCE") == 0) aType = StepDimTol_GTTRoundnessTolerance;
+ else if (strcmp(aLast, "STRAIGHTNESS_TOLERANCE") == 0) aType = StepDimTol_GTTStraightnessTolerance;
+ else if (strcmp(aLast, "SURFACE_PROFILE_TOLERANCE") == 0) aType = StepDimTol_GTTSurfaceProfileTolerance;
+ else if (strcmp(aLast, "SYMMETRY_TOLERANCE") == 0) aType = StepDimTol_GTTSymmetryTolerance;
+ else if (strcmp(aLast, "TOTAL_RUNOUT_TOLERANCE") == 0) aType = StepDimTol_GTTTotalRunoutTolerance;
+ else ach->AddFail("The type of geometric tolerance is not supported");
+
+ // Initialize entity
+ ent->Init(aName, aDescription, aMagnitude, aTolerancedShapeAspect, aGTWDR, aType);
+}
+
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWGeoTolAndGeoTolWthDatRef::WriteStep
+ (StepData_StepWriter& SW,
+ const Handle(StepDimTol_GeoTolAndGeoTolWthDatRef)& ent) const
+{
+ StepDimTol_GeometricToleranceType aType = ent->GetToleranceType();
+ if (aType == StepDimTol_GTTAngularityTolerance)
+ SW.StartEntity("ANGULARITY_TOLERANCE");
+ else if (aType == StepDimTol_GTTCircularRunoutTolerance)
+ SW.StartEntity("CIRCULAR_RUNOUT_TOLERANCE");
+ else if (aType == StepDimTol_GTTCoaxialityTolerance)
+ SW.StartEntity("COAXIALITY_TOLERANCE");
+ else if (aType == StepDimTol_GTTConcentricityTolerance)
+ SW.StartEntity("CONCENTRICITY_TOLERANCE");
+ else if (aType == StepDimTol_GTTCylindricityTolerance)
+ SW.StartEntity("CYLINDRICITY_TOLERANCE");
+ else if (aType == StepDimTol_GTTFlatnessTolerance)
+ SW.StartEntity("FLATNESS_TOLERANCE");
+
+ SW.StartEntity("GEOMETRIC_TOLERANCE");
+ SW.Send(ent->Name());
+ SW.Send(ent->Description());
+ SW.Send(ent->Magnitude());
+ SW.Send(ent->TolerancedShapeAspect().Value());
+ SW.StartEntity("GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE");
+ SW.OpenSub();
+ for(Standard_Integer i4=1; i4<=ent->GetGeometricToleranceWithDatumReference()->DatumSystemAP242()->Length(); i4++) {
+ StepDimTol_DatumSystemOrReference Var0 =
+ ent->GetGeometricToleranceWithDatumReference()->DatumSystemAP242()->Value(i4);
+ SW.Send(Var0.Value());
+ }
+ SW.CloseSub();
+
+ if (aType == StepDimTol_GTTLineProfileTolerance)
+ SW.StartEntity("LINE_PROFILE_TOLERANCE");
+ else if (aType == StepDimTol_GTTParallelismTolerance)
+ SW.StartEntity("PARALLELISM_TOLERANCE");
+ else if (aType == StepDimTol_GTTPerpendicularityTolerance)
+ SW.StartEntity("PERPENDICULARITY_TOLERANCE");
+ else if (aType == StepDimTol_GTTPositionTolerance)
+ SW.StartEntity("POSITION_TOLERANCE");
+ else if (aType == StepDimTol_GTTRoundnessTolerance)
+ SW.StartEntity("ROUNDNESS_TOLERANCE");
+ else if (aType == StepDimTol_GTTStraightnessTolerance)
+ SW.StartEntity("STRAIGHTNESS_TOLERANCE");
+ else if (aType == StepDimTol_GTTSurfaceProfileTolerance)
+ SW.StartEntity("SURFACE_PROFILE_TOLERANCE");
+ else if (aType == StepDimTol_GTTSymmetryTolerance)
+ SW.StartEntity("SYMMETRY_TOLERANCE");
+ else if (aType == StepDimTol_GTTTotalRunoutTolerance)
+ SW.StartEntity("TOTAL_RUNOUT_TOLERANCE");
+}
+
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWGeoTolAndGeoTolWthDatRef::Share
+ (const Handle(StepDimTol_GeoTolAndGeoTolWthDatRef)& ent,
+ Interface_EntityIterator& iter) const
+{
+ // Own fields of GeometricTolerance
+ iter.AddItem (ent->Magnitude());
+ iter.AddItem (ent->TolerancedShapeAspect().Value());
+ // Own fields of GeometricToleranceWithDatumReference
+ for (Standard_Integer i3=1; i3<=ent->GetGeometricToleranceWithDatumReference()->DatumSystemAP242()->Length(); i3++ ) {
+ StepDimTol_DatumSystemOrReference Var0 = ent->GetGeometricToleranceWithDatumReference()->DatumSystemAP242()->Value(i3);
+ iter.AddItem (Var0.Value());
+ }
+}
--- /dev/null
+// Created on: 2015-08-10
+// Created by: Irina KRYLOVA
+// 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 _RWStepDimTol_RWGeoTolAndGeoTolWthDatRef_HeaderFile
+#define _RWStepDimTol_RWGeoTolAndGeoTolWthDatRef_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+class StepData_StepReaderData;
+class Interface_Check;
+class StepDimTol_GeoTolAndGeoTolWthDatRef;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write Module for GeoTolAndGeoTolWthDatRef
+class RWStepDimTol_RWGeoTolAndGeoTolWthDatRef
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ Standard_EXPORT RWStepDimTol_RWGeoTolAndGeoTolWthDatRef();
+
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepDimTol_GeoTolAndGeoTolWthDatRef)& ent) const;
+
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepDimTol_GeoTolAndGeoTolWthDatRef)& ent) const;
+
+ Standard_EXPORT void Share (const Handle(StepDimTol_GeoTolAndGeoTolWthDatRef)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepDimTol_RWGeoTolAndGeoTolWthDatRef_HeaderFile
--- /dev/null
+// Created on: 2015-08-10
+// Created by: Irina KRYLOVA
+// 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.
+
+
+#include <Interface_Check.hxx>
+#include <Interface_EntityIterator.hxx>
+#include <RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMod.hxx>
+#include <StepBasic_MeasureWithUnit.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepDimTol_DatumReference.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
+#include <StepDimTol_GeometricToleranceType.hxx>
+#include <StepDimTol_GeometricToleranceWithDatumReference.hxx>
+#include <StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod.hxx>
+#include <StepDimTol_HArray1OfDatumSystemOrReference.hxx>
+#include <StepDimTol_GeometricToleranceWithModifiers.hxx>
+
+//=======================================================================
+//function : RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMod
+//purpose :
+//=======================================================================
+RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMod::RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMod()
+{
+}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMod::ReadStep
+ (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num0, Handle(Interface_Check)& ach,
+ const Handle(StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod)& ent) const
+{
+ Standard_Integer num = 0;//num0;
+ data->NamedForComplex("GEOMETRIC_TOLERANCE",num0,num,ach);
+ if (!data->CheckNbParams(num,4,ach,"geometric_tolerance")) return;
+ // Own fields of GeometricTolerance
+ Handle(TCollection_HAsciiString) aName;
+ data->ReadString (num, 1, "name", ach, aName);
+ Handle(TCollection_HAsciiString) aDescription;
+ data->ReadString (num, 2, "description", ach, aDescription);
+ Handle(StepBasic_MeasureWithUnit) aMagnitude;
+ data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aMagnitude);
+ StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
+ data->ReadEntity (num, 4, "toleranced_shape_aspect", ach, aTolerancedShapeAspect);
+
+ data->NamedForComplex("GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE",num0,num,ach);
+ // Own fields of GeometricToleranceWithDatumReference
+ Handle(StepDimTol_HArray1OfDatumSystemOrReference) aDatumSystem;
+ Standard_Integer sub5 = 0;
+ if ( data->ReadSubList (num, 1, "datum_system", ach, sub5) ) {
+ Standard_Integer nb0 = data->NbParams(sub5);
+ aDatumSystem = new StepDimTol_HArray1OfDatumSystemOrReference (1, nb0);
+ Standard_Integer num2 = sub5;
+ for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
+ StepDimTol_DatumSystemOrReference anIt0;
+ data->ReadEntity (num2, i0, "datum_system_or_reference", ach, anIt0);
+ aDatumSystem->SetValue(i0, anIt0);
+ }
+ }
+ // Initialize entity
+ Handle(StepDimTol_GeometricToleranceWithDatumReference) aGTWDR =
+ new StepDimTol_GeometricToleranceWithDatumReference;
+ aGTWDR->SetDatumSystem(aDatumSystem);
+
+ data->NamedForComplex("GEOMETRIC_TOLERANCE_WITH_MODIFIERS",num0,num,ach);
+ // Own fields of ModifiedGeometricTolerance
+ Handle(StepDimTol_HArray1OfGeometricToleranceModifier) aModifiers;
+ Standard_Integer sub = 0;
+ if ( data->ReadSubList (num, 1, "modifiers", ach, sub) ) {
+ Standard_Integer nb0 = data->NbParams(sub5);
+ aModifiers = new StepDimTol_HArray1OfGeometricToleranceModifier (1, nb0);
+ Standard_Integer num2 = sub;
+ for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
+ StepDimTol_GeometricToleranceModifier anIt0 = StepDimTol_GTMMaximumMaterialRequirement;
+ if (data->ParamType (num2, i0) == Interface_ParamEnum) {
+ Standard_CString text = data->ParamCValue(num2, i0);
+ if (strcmp(text, ".ANY_CROSS_SECTION.")==0) anIt0 = StepDimTol_GTMAnyCrossSection;
+ else if (strcmp(text, ".COMMON_ZONE.")==0) anIt0 = StepDimTol_GTMCommonZone;
+ else if (strcmp(text, ".EACH_RADIAL_ELEMENT.")==0) anIt0 = StepDimTol_GTMEachRadialElement;
+ else if (strcmp(text, ".FREE_STATE.")==0) anIt0 = StepDimTol_GTMFreeState;
+ else if (strcmp(text, ".LEAST_MATERIAL_REQUIREMENT.")==0) anIt0 = StepDimTol_GTMLeastMaterialRequirement;
+ else if (strcmp(text, ".LINE_ELEMENT.")==0) anIt0 = StepDimTol_GTMLineElement;
+ else if (strcmp(text, ".MAJOR_DIAMETER.")==0) anIt0 = StepDimTol_GTMMajorDiameter;
+ else if (strcmp(text, ".MAXIMUM_MATERIAL_REQUIREMENT.")==0) anIt0 = StepDimTol_GTMMaximumMaterialRequirement;
+ else if (strcmp(text, ".MINOR_DIAMETER.")==0) anIt0 = StepDimTol_GTMMinorDiameter;
+ else if (strcmp(text, ".NOT_CONVEX.")==0) anIt0 = StepDimTol_GTMNotConvex;
+ else if (strcmp(text, ".PITCH_DIAMETER.")==0) anIt0 = StepDimTol_GTMPitchDiameter;
+ else if (strcmp(text, ".RECIPROCITY_REQUIREMENT.")==0) anIt0 = StepDimTol_GTMReciprocityRequirement;
+ else if (strcmp(text, ".SEPARATE_REQUIREMENT.")==0) anIt0 = StepDimTol_GTMSeparateRequirement;
+ else if (strcmp(text, ".STATISTICAL_TOLERANCE.")==0) anIt0 = StepDimTol_GTMStatisticalTolerance;
+ else if (strcmp(text, ".TANGENT_PLANE.")==0) anIt0 = StepDimTol_GTMTangentPlane;
+ else ach->AddFail("Parameter #5 (modifiers) has not allowed value");
+ }
+ else ach->AddFail("Parameter #5 (modifier) is not set of enumerations");
+ aModifiers->SetValue(i0, anIt0);
+ }
+ }
+ Handle(StepDimTol_GeometricToleranceWithModifiers) aGTWM = new StepDimTol_GeometricToleranceWithModifiers;
+ aGTWM->SetModifiers(aModifiers);
+
+ //Choose type of geometric tolerance
+ TColStd_SequenceOfAsciiString aTypes;
+ data->ComplexType(num0, aTypes);
+ Standard_CString aFirst = aTypes.First().ToCString();
+ Standard_CString aLast = aTypes.Last().ToCString();
+ StepDimTol_GeometricToleranceType aType = StepDimTol_GTTPositionTolerance;
+ if (strcmp(aFirst, "ANGULARITY_TOLERANCE") == 0) aType = StepDimTol_GTTAngularityTolerance;
+ else if (strcmp(aFirst, "CIRCULAR_RUNOUT_TOLERANCE") == 0) aType = StepDimTol_GTTCircularRunoutTolerance;
+ else if (strcmp(aFirst, "COAXIALITY_TOLERANCE") == 0) aType = StepDimTol_GTTCoaxialityTolerance;
+ else if (strcmp(aFirst, "CONCENTRICITY_TOLERANCE") == 0) aType = StepDimTol_GTTConcentricityTolerance;
+ else if (strcmp(aFirst, "CYLINDRICITY_TOLERANCE") == 0) aType = StepDimTol_GTTCylindricityTolerance;
+ else if (strcmp(aFirst, "FLATNESS_TOLERANCE") == 0) aType = StepDimTol_GTTFlatnessTolerance;
+ else if (strcmp(aLast, "LINE_PROFILE_TOLERANCE") == 0) aType = StepDimTol_GTTLineProfileTolerance;
+ else if (strcmp(aLast, "PARALLELISM_TOLERANCE") == 0) aType = StepDimTol_GTTParallelismTolerance;
+ else if (strcmp(aLast, "PERPENDICULARITY_TOLERANCE") == 0) aType = StepDimTol_GTTPerpendicularityTolerance;
+ else if (strcmp(aLast, "POSITION_TOLERANCE") == 0) aType = StepDimTol_GTTPositionTolerance;
+ else if (strcmp(aLast, "ROUNDNESS_TOLERANCE") == 0) aType = StepDimTol_GTTRoundnessTolerance;
+ else if (strcmp(aLast, "STRAIGHTNESS_TOLERANCE") == 0) aType = StepDimTol_GTTStraightnessTolerance;
+ else if (strcmp(aLast, "SURFACE_PROFILE_TOLERANCE") == 0) aType = StepDimTol_GTTSurfaceProfileTolerance;
+ else if (strcmp(aLast, "SYMMETRY_TOLERANCE") == 0) aType = StepDimTol_GTTSymmetryTolerance;
+ else if (strcmp(aLast, "TOTAL_RUNOUT_TOLERANCE") == 0) aType = StepDimTol_GTTTotalRunoutTolerance;
+ else ach->AddFail("The type of geometric tolerance is not supported");
+
+ // Initialize entity
+ ent->Init(aName, aDescription, aMagnitude, aTolerancedShapeAspect, aGTWDR, aGTWM, aType);
+
+}
+
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMod::WriteStep
+ (StepData_StepWriter& SW,
+ const Handle(StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod)& ent) const
+{
+ StepDimTol_GeometricToleranceType aType = ent->GetToleranceType();
+ if (aType == StepDimTol_GTTAngularityTolerance)
+ SW.StartEntity("ANGULARITY_TOLERANCE");
+ else if (aType == StepDimTol_GTTCircularRunoutTolerance)
+ SW.StartEntity("CIRCULAR_RUNOUT_TOLERANCE");
+ else if (aType == StepDimTol_GTTCoaxialityTolerance)
+ SW.StartEntity("COAXIALITY_TOLERANCE");
+ else if (aType == StepDimTol_GTTConcentricityTolerance)
+ SW.StartEntity("CONCENTRICITY_TOLERANCE");
+ else if (aType == StepDimTol_GTTCylindricityTolerance)
+ SW.StartEntity("CYLINDRICITY_TOLERANCE");
+ else if (aType == StepDimTol_GTTFlatnessTolerance)
+ SW.StartEntity("FLATNESS_TOLERANCE");
+
+ SW.StartEntity("GEOMETRIC_TOLERANCE");
+ SW.Send(ent->Name());
+ SW.Send(ent->Description());
+ SW.Send(ent->Magnitude());
+ SW.Send(ent->TolerancedShapeAspect().Value());
+ SW.StartEntity("GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE");
+ SW.OpenSub();
+ for(Standard_Integer i4=1; i4<=ent->GetGeometricToleranceWithDatumReference()->DatumSystemAP242()->Length(); i4++) {
+ StepDimTol_DatumSystemOrReference Var0 =
+ ent->GetGeometricToleranceWithDatumReference()->DatumSystemAP242()->Value(i4);
+ SW.Send(Var0.Value());
+ }
+ SW.CloseSub();
+
+ if (aType == StepDimTol_GTTLineProfileTolerance)
+ SW.StartEntity("LINE_PROFILE_TOLERANCE");
+ else if (aType == StepDimTol_GTTParallelismTolerance)
+ SW.StartEntity("PARALLELISM_TOLERANCE");
+ else if (aType == StepDimTol_GTTPerpendicularityTolerance)
+ SW.StartEntity("PERPENDICULARITY_TOLERANCE");
+ else if (aType == StepDimTol_GTTPositionTolerance)
+ SW.StartEntity("POSITION_TOLERANCE");
+ else if (aType == StepDimTol_GTTRoundnessTolerance)
+ SW.StartEntity("ROUNDNESS_TOLERANCE");
+ else if (aType == StepDimTol_GTTStraightnessTolerance)
+ SW.StartEntity("STRAIGHTNESS_TOLERANCE");
+ else if (aType == StepDimTol_GTTSurfaceProfileTolerance)
+ SW.StartEntity("SURFACE_PROFILE_TOLERANCE");
+ else if (aType == StepDimTol_GTTSymmetryTolerance)
+ SW.StartEntity("SYMMETRY_TOLERANCE");
+ else if (aType == StepDimTol_GTTTotalRunoutTolerance)
+ SW.StartEntity("TOTAL_RUNOUT_TOLERANCE");
+}
+
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMod::Share
+ (const Handle(StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod)& ent,
+ Interface_EntityIterator& iter) const
+{
+ // Own fields of GeometricTolerance
+ iter.AddItem (ent->Magnitude());
+ iter.AddItem (ent->TolerancedShapeAspect().Value());
+ // Own fields of GeometricToleranceWithDatumReference
+ for (Standard_Integer i3=1; i3<=ent->GetGeometricToleranceWithDatumReference()->DatumSystemAP242()->Length(); i3++ ) {
+ StepDimTol_DatumSystemOrReference Var0 = ent->GetGeometricToleranceWithDatumReference()->DatumSystemAP242()->Value(i3);
+ iter.AddItem (Var0.Value());
+ }
+}
--- /dev/null
+// Created on: 2015-08-10
+// Created by: Irina KRYLOVA
+// 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 _RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMod_HeaderFile
+#define _RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMod_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+class StepData_StepReaderData;
+class Interface_Check;
+class StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write Module for GeoTolAndGeoTolWthDatRefAndGeoTolWthMod
+class RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMod
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ Standard_EXPORT RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMod();
+
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod)& ent) const;
+
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod)& ent) const;
+
+ Standard_EXPORT void Share (const Handle(StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMod_HeaderFile
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_DatumReference.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
#include <StepDimTol_GeometricToleranceWithDatumReference.hxx>
#include <StepDimTol_GeoTolAndGeoTolWthDatRefAndModGeoTolAndPosTol.hxx>
-#include <StepDimTol_HArray1OfDatumReference.hxx>
+#include <StepDimTol_HArray1OfDatumSystemOrReference.hxx>
#include <StepDimTol_LimitCondition.hxx>
#include <StepDimTol_ModifiedGeometricTolerance.hxx>
-#include <StepRepr_ShapeAspect.hxx>
//=======================================================================
//function : RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndModGeoTolAndPosTol
data->ReadString (num, 2, "description", ach, aDescription);
Handle(StepBasic_MeasureWithUnit) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aMagnitude);
- Handle(StepRepr_ShapeAspect) aTolerancedShapeAspect;
- data->ReadEntity (num, 4, "toleranced_shape_aspect", ach, STANDARD_TYPE(StepRepr_ShapeAspect), aTolerancedShapeAspect);
+ StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
+ data->ReadEntity (num, 4, "toleranced_shape_aspect", ach, aTolerancedShapeAspect);
data->NamedForComplex("GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE",num0,num,ach);
// Own fields of GeometricToleranceWithDatumReference
- Handle(StepDimTol_HArray1OfDatumReference) aDatumSystem;
+ Handle(StepDimTol_HArray1OfDatumSystemOrReference) aDatumSystem;
Standard_Integer sub5 = 0;
if ( data->ReadSubList (num, 1, "datum_system", ach, sub5) ) {
Standard_Integer nb0 = data->NbParams(sub5);
- aDatumSystem = new StepDimTol_HArray1OfDatumReference (1, nb0);
+ aDatumSystem = new StepDimTol_HArray1OfDatumSystemOrReference (1, nb0);
Standard_Integer num2 = sub5;
for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
- Handle(StepDimTol_DatumReference) anIt0;
- data->ReadEntity (num2, i0, "datum_reference", ach, STANDARD_TYPE(StepDimTol_DatumReference), anIt0);
+ StepDimTol_DatumSystemOrReference anIt0;
+ data->ReadEntity (num2, i0, "datum_system_or_reference", ach, anIt0);
aDatumSystem->SetValue(i0, anIt0);
}
}
SW.Send(ent->Name());
SW.Send(ent->Description());
SW.Send(ent->Magnitude());
- SW.Send(ent->TolerancedShapeAspect());
+ SW.Send(ent->TolerancedShapeAspect().Value());
SW.StartEntity("GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE");
SW.OpenSub();
- for(Standard_Integer i4=1; i4<=ent->GetGeometricToleranceWithDatumReference()->DatumSystem()->Length(); i4++) {
- Handle(StepDimTol_DatumReference) Var0 =
- ent->GetGeometricToleranceWithDatumReference()->DatumSystem()->Value(i4);
- SW.Send(Var0);
+ for(Standard_Integer i4=1; i4<=ent->GetGeometricToleranceWithDatumReference()->DatumSystemAP242()->Length(); i4++) {
+ StepDimTol_DatumSystemOrReference Var0 =
+ ent->GetGeometricToleranceWithDatumReference()->DatumSystemAP242()->Value(i4);
+ SW.Send(Var0.Value());
}
SW.CloseSub();
SW.StartEntity("MODIFIED_GEOMETRIC_TOLERANCE");
{
// Own fields of GeometricTolerance
iter.AddItem (ent->Magnitude());
- iter.AddItem (ent->TolerancedShapeAspect());
+ iter.AddItem (ent->TolerancedShapeAspect().Value());
// Own fields of GeometricToleranceWithDatumReference
- for (Standard_Integer i3=1; i3<=ent->GetGeometricToleranceWithDatumReference()->DatumSystem()->Length(); i3++ ) {
- Handle(StepDimTol_DatumReference) Var0 = ent->GetGeometricToleranceWithDatumReference()->DatumSystem()->Value(i3);
- iter.AddItem (Var0);
+ for (Standard_Integer i3=1; i3<=ent->GetGeometricToleranceWithDatumReference()->DatumSystemAP242()->Length(); i3++ ) {
+ StepDimTol_DatumSystemOrReference Var0 = ent->GetGeometricToleranceWithDatumReference()->DatumSystemAP242()->Value(i3);
+ iter.AddItem (Var0.Value());
}
}
--- /dev/null
+// Created on: 2015-08-11
+// Created by: Irina KRYLOVA
+// 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.
+
+
+#include <Interface_Check.hxx>
+#include <Interface_EntityIterator.hxx>
+#include <RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndUneqDisGeoTol.hxx>
+#include <StepBasic_LengthMeasureWithUnit.hxx>
+#include <StepBasic_MeasureWithUnit.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepDimTol_DatumReference.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
+#include <StepDimTol_GeometricToleranceType.hxx>
+#include <StepDimTol_GeometricToleranceWithDatumReference.hxx>
+#include <StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol.hxx>
+#include <StepDimTol_HArray1OfDatumSystemOrReference.hxx>
+#include <StepDimTol_UnequallyDisposedGeometricTolerance.hxx>
+
+//=======================================================================
+//function : RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndUneqDisGeoTol
+//purpose :
+//=======================================================================
+RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndUneqDisGeoTol::RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndUneqDisGeoTol()
+{
+}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndUneqDisGeoTol::ReadStep
+ (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num0, Handle(Interface_Check)& ach,
+ const Handle(StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol)& ent) const
+{
+ Standard_Integer num = 0;//num0;
+ data->NamedForComplex("GEOMETRIC_TOLERANCE",num0,num,ach);
+ if (!data->CheckNbParams(num,4,ach,"geometric_tolerance")) return;
+ // Own fields of GeometricTolerance
+ Handle(TCollection_HAsciiString) aName;
+ data->ReadString (num, 1, "name", ach, aName);
+ Handle(TCollection_HAsciiString) aDescription;
+ data->ReadString (num, 2, "description", ach, aDescription);
+ Handle(StepBasic_MeasureWithUnit) aMagnitude;
+ data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aMagnitude);
+ StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
+ data->ReadEntity (num, 4, "toleranced_shape_aspect", ach, aTolerancedShapeAspect);
+
+ data->NamedForComplex("GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE",num0,num,ach);
+ // Own fields of GeometricToleranceWithDatumReference
+ Handle(StepDimTol_HArray1OfDatumSystemOrReference) aDatumSystem;
+ Standard_Integer sub5 = 0;
+ if ( data->ReadSubList (num, 1, "datum_system", ach, sub5) ) {
+ Standard_Integer nb0 = data->NbParams(sub5);
+ aDatumSystem = new StepDimTol_HArray1OfDatumSystemOrReference (1, nb0);
+ Standard_Integer num2 = sub5;
+ for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
+ StepDimTol_DatumSystemOrReference anIt0;
+ data->ReadEntity (num2, i0, "datum_system_or_reference", ach, anIt0);
+ aDatumSystem->SetValue(i0, anIt0);
+ }
+ }
+ // Initialize entity
+ Handle(StepDimTol_GeometricToleranceWithDatumReference) aGTWDR =
+ new StepDimTol_GeometricToleranceWithDatumReference;
+ aGTWDR->SetDatumSystem(aDatumSystem);
+
+ data->NamedForComplex("UNEQUALLY_DISPOSED_GEOMETRIC_TOLERANCE", num0, num, ach);
+ Handle (StepBasic_LengthMeasureWithUnit) aDisplacement;
+ data->ReadEntity(num, 1, "displacement", ach, STANDARD_TYPE(StepBasic_LengthMeasureWithUnit), aDisplacement);
+ //Initialize entity
+ Handle(StepDimTol_UnequallyDisposedGeometricTolerance) anUDGT = new
+ StepDimTol_UnequallyDisposedGeometricTolerance;
+ anUDGT->SetDisplacement(aDisplacement);
+
+ //Choose type of geometric tolerance
+ TColStd_SequenceOfAsciiString aTypes;
+ data->ComplexType(num0, aTypes);
+ Standard_CString aFirst = aTypes.First().ToCString();
+ Standard_CString aLast = aTypes.Value(3).ToCString();
+ StepDimTol_GeometricToleranceType aType = StepDimTol_GTTPositionTolerance;
+ if (strcmp(aFirst, "ANGULARITY_TOLERANCE") == 0) aType = StepDimTol_GTTAngularityTolerance;
+ else if (strcmp(aFirst, "CIRCULAR_RUNOUT_TOLERANCE") == 0) aType = StepDimTol_GTTCircularRunoutTolerance;
+ else if (strcmp(aFirst, "COAXIALITY_TOLERANCE") == 0) aType = StepDimTol_GTTCoaxialityTolerance;
+ else if (strcmp(aFirst, "CONCENTRICITY_TOLERANCE") == 0) aType = StepDimTol_GTTConcentricityTolerance;
+ else if (strcmp(aFirst, "CYLINDRICITY_TOLERANCE") == 0) aType = StepDimTol_GTTCylindricityTolerance;
+ else if (strcmp(aFirst, "FLATNESS_TOLERANCE") == 0) aType = StepDimTol_GTTFlatnessTolerance;
+ else if (strcmp(aLast, "LINE_PROFILE_TOLERANCE") == 0) aType = StepDimTol_GTTLineProfileTolerance;
+ else if (strcmp(aLast, "PARALLELISM_TOLERANCE") == 0) aType = StepDimTol_GTTParallelismTolerance;
+ else if (strcmp(aLast, "PERPENDICULARITY_TOLERANCE") == 0) aType = StepDimTol_GTTPerpendicularityTolerance;
+ else if (strcmp(aLast, "POSITION_TOLERANCE") == 0) aType = StepDimTol_GTTPositionTolerance;
+ else if (strcmp(aLast, "ROUNDNESS_TOLERANCE") == 0) aType = StepDimTol_GTTRoundnessTolerance;
+ else if (strcmp(aLast, "STRAIGHTNESS_TOLERANCE") == 0) aType = StepDimTol_GTTStraightnessTolerance;
+ else if (strcmp(aLast, "SURFACE_PROFILE_TOLERANCE") == 0) aType = StepDimTol_GTTSurfaceProfileTolerance;
+ else if (strcmp(aLast, "SYMMETRY_TOLERANCE") == 0) aType = StepDimTol_GTTSymmetryTolerance;
+ else if (strcmp(aLast, "TOTAL_RUNOUT_TOLERANCE") == 0) aType = StepDimTol_GTTTotalRunoutTolerance;
+ else ach->AddFail("The type of geometric tolerance is not supported");
+
+ // Initialize entity
+ ent->Init(aName, aDescription, aMagnitude, aTolerancedShapeAspect, aGTWDR, aType, anUDGT);
+}
+
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndUneqDisGeoTol::WriteStep
+ (StepData_StepWriter& SW,
+ const Handle(StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol)& ent) const
+{
+ StepDimTol_GeometricToleranceType aType = ent->GetToleranceType();
+ if (aType == StepDimTol_GTTAngularityTolerance)
+ SW.StartEntity("ANGULARITY_TOLERANCE");
+ else if (aType == StepDimTol_GTTCircularRunoutTolerance)
+ SW.StartEntity("CIRCULAR_RUNOUT_TOLERANCE");
+ else if (aType == StepDimTol_GTTCoaxialityTolerance)
+ SW.StartEntity("COAXIALITY_TOLERANCE");
+ else if (aType == StepDimTol_GTTConcentricityTolerance)
+ SW.StartEntity("CONCENTRICITY_TOLERANCE");
+ else if (aType == StepDimTol_GTTCylindricityTolerance)
+ SW.StartEntity("CYLINDRICITY_TOLERANCE");
+ else if (aType == StepDimTol_GTTFlatnessTolerance)
+ SW.StartEntity("FLATNESS_TOLERANCE");
+
+ SW.StartEntity("GEOMETRIC_TOLERANCE");
+ SW.Send(ent->Name());
+ SW.Send(ent->Description());
+ SW.Send(ent->Magnitude());
+ SW.Send(ent->TolerancedShapeAspect().Value());
+ SW.StartEntity("GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE");
+ SW.OpenSub();
+ for(Standard_Integer i4=1; i4<=ent->GetGeometricToleranceWithDatumReference()->DatumSystemAP242()->Length(); i4++) {
+ StepDimTol_DatumSystemOrReference Var0 =
+ ent->GetGeometricToleranceWithDatumReference()->DatumSystemAP242()->Value(i4);
+ SW.Send(Var0.Value());
+ }
+ SW.CloseSub();
+
+ if (aType == StepDimTol_GTTLineProfileTolerance)
+ SW.StartEntity("LINE_PROFILE_TOLERANCE");
+ else if (aType == StepDimTol_GTTParallelismTolerance)
+ SW.StartEntity("PARALLELISM_TOLERANCE");
+ else if (aType == StepDimTol_GTTPerpendicularityTolerance)
+ SW.StartEntity("PERPENDICULARITY_TOLERANCE");
+ else if (aType == StepDimTol_GTTPositionTolerance)
+ SW.StartEntity("POSITION_TOLERANCE");
+ else if (aType == StepDimTol_GTTRoundnessTolerance)
+ SW.StartEntity("ROUNDNESS_TOLERANCE");
+ else if (aType == StepDimTol_GTTStraightnessTolerance)
+ SW.StartEntity("STRAIGHTNESS_TOLERANCE");
+ else if (aType == StepDimTol_GTTSurfaceProfileTolerance)
+ SW.StartEntity("SURFACE_PROFILE_TOLERANCE");
+ else if (aType == StepDimTol_GTTSymmetryTolerance)
+ SW.StartEntity("SYMMETRY_TOLERANCE");
+ else if (aType == StepDimTol_GTTTotalRunoutTolerance)
+ SW.StartEntity("TOTAL_RUNOUT_TOLERANCE");
+
+ SW.StartEntity("UNEQUALLY_DISPOSED_GEOMETRIC_TOLRANCE");
+ SW.Send(ent->GetUnequallyDisposedGeometricTolerance()->Displacement());
+}
+
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndUneqDisGeoTol::Share
+ (const Handle(StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol)& ent,
+ Interface_EntityIterator& iter) const
+{
+ // Own fields of GeometricTolerance
+ iter.AddItem (ent->Magnitude());
+ iter.AddItem (ent->TolerancedShapeAspect().Value());
+ // Own fields of GeometricToleranceWithDatumReference
+ for (Standard_Integer i3=1; i3<=ent->GetGeometricToleranceWithDatumReference()->DatumSystemAP242()->Length(); i3++ ) {
+ StepDimTol_DatumSystemOrReference Var0 = ent->GetGeometricToleranceWithDatumReference()->DatumSystemAP242()->Value(i3);
+ iter.AddItem (Var0.Value());
+ }
+}
--- /dev/null
+// Created on: 2015-08-11
+// Created by: Irina KRYLOVA
+// 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 _RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndUneqDisGeoTol_HeaderFile
+#define _RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndUneqDisGeoTol_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+class StepData_StepReaderData;
+class Interface_Check;
+class StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write Module for GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol
+class RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndUneqDisGeoTol
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ Standard_EXPORT RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndUneqDisGeoTol();
+
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol)& ent) const;
+
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol)& ent) const;
+
+ Standard_EXPORT void Share (const Handle(StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndUneqDisGeoTol_HeaderFile
--- /dev/null
+// Created on: 2015-08-10
+// Created by: Irina KRYLOVA
+// 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.
+
+
+#include <Interface_Check.hxx>
+#include <Interface_EntityIterator.hxx>
+#include <RWStepDimTol_RWGeoTolAndGeoTolWthMod.hxx>
+#include <StepBasic_MeasureWithUnit.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
+#include <StepDimTol_GeometricToleranceType.hxx>
+#include <StepDimTol_GeoTolAndGeoTolWthMod.hxx>
+#include <StepDimTol_GeometricToleranceWithModifiers.hxx>
+
+//=======================================================================
+//function : RWStepDimTol_RWGeoTolAndGeoTolWthMod
+//purpose :
+//=======================================================================
+RWStepDimTol_RWGeoTolAndGeoTolWthMod::RWStepDimTol_RWGeoTolAndGeoTolWthMod()
+{
+}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWGeoTolAndGeoTolWthMod::ReadStep
+ (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num0, Handle(Interface_Check)& ach,
+ const Handle(StepDimTol_GeoTolAndGeoTolWthMod)& ent) const
+{
+ Standard_Integer num = 0;//num0;
+ data->NamedForComplex("GEOMETRIC_TOLERANCE",num0,num,ach);
+ if (!data->CheckNbParams(num,4,ach,"geometric_tolerance")) return;
+ // Own fields of GeometricTolerance
+ Handle(TCollection_HAsciiString) aName;
+ data->ReadString (num, 1, "name", ach, aName);
+ Handle(TCollection_HAsciiString) aDescription;
+ data->ReadString (num, 2, "description", ach, aDescription);
+ Handle(StepBasic_MeasureWithUnit) aMagnitude;
+ data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aMagnitude);
+ StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
+ data->ReadEntity (num, 4, "toleranced_shape_aspect", ach, aTolerancedShapeAspect);
+
+ data->NamedForComplex("GEOMETRIC_TOLERANCE_WITH_MODIFIERS",num0,num,ach);
+ // Own fields of ModifiedGeometricTolerance
+ Handle(StepDimTol_HArray1OfGeometricToleranceModifier) aModifiers;
+ Standard_Integer sub = 0;
+ if ( data->ReadSubList (num, 1, "modifiers", ach, sub) ) {
+ Standard_Integer nb0 = data->NbParams(sub);
+ aModifiers = new StepDimTol_HArray1OfGeometricToleranceModifier (1, nb0);
+ Standard_Integer num2 = sub;
+ for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
+ StepDimTol_GeometricToleranceModifier anIt0 = StepDimTol_GTMMaximumMaterialRequirement;
+ if (data->ParamType (num2, i0) == Interface_ParamEnum) {
+ Standard_CString text = data->ParamCValue(num2, i0);
+ if (strcmp(text, ".ANY_CROSS_SECTION.")==0) anIt0 = StepDimTol_GTMAnyCrossSection;
+ else if (strcmp(text, ".COMMON_ZONE.")==0) anIt0 = StepDimTol_GTMCommonZone;
+ else if (strcmp(text, ".EACH_RADIAL_ELEMENT.")==0) anIt0 = StepDimTol_GTMEachRadialElement;
+ else if (strcmp(text, ".FREE_STATE.")==0) anIt0 = StepDimTol_GTMFreeState;
+ else if (strcmp(text, ".LEAST_MATERIAL_REQUIREMENT.")==0) anIt0 = StepDimTol_GTMLeastMaterialRequirement;
+ else if (strcmp(text, ".LINE_ELEMENT.")==0) anIt0 = StepDimTol_GTMLineElement;
+ else if (strcmp(text, ".MAJOR_DIAMETER.")==0) anIt0 = StepDimTol_GTMMajorDiameter;
+ else if (strcmp(text, ".MAXIMUM_MATERIAL_REQUIREMENT.")==0) anIt0 = StepDimTol_GTMMaximumMaterialRequirement;
+ else if (strcmp(text, ".MINOR_DIAMETER.")==0) anIt0 = StepDimTol_GTMMinorDiameter;
+ else if (strcmp(text, ".NOT_CONVEX.")==0) anIt0 = StepDimTol_GTMNotConvex;
+ else if (strcmp(text, ".PITCH_DIAMETER.")==0) anIt0 = StepDimTol_GTMPitchDiameter;
+ else if (strcmp(text, ".RECIPROCITY_REQUIREMENT.")==0) anIt0 = StepDimTol_GTMReciprocityRequirement;
+ else if (strcmp(text, ".SEPARATE_REQUIREMENT.")==0) anIt0 = StepDimTol_GTMSeparateRequirement;
+ else if (strcmp(text, ".STATISTICAL_TOLERANCE.")==0) anIt0 = StepDimTol_GTMStatisticalTolerance;
+ else if (strcmp(text, ".TANGENT_PLANE.")==0) anIt0 = StepDimTol_GTMTangentPlane;
+ else ach->AddFail("Parameter #5 (modifiers) has not allowed value");
+ }
+ else ach->AddFail("Parameter #5 (modifier) is not set of enumerations");
+ aModifiers->SetValue(i0, anIt0);
+ }
+ }
+ Handle(StepDimTol_GeometricToleranceWithModifiers) aGTWM = new StepDimTol_GeometricToleranceWithModifiers;
+ aGTWM->SetModifiers(aModifiers);
+
+ //Choose type of geometric tolerance
+ TColStd_SequenceOfAsciiString aTypes;
+ data->ComplexType(num0, aTypes);
+ Standard_CString aFirst = aTypes.First().ToCString();
+ Standard_CString aLast = aTypes.Last().ToCString();
+ StepDimTol_GeometricToleranceType aType = StepDimTol_GTTPositionTolerance;
+ if (strcmp(aFirst, "ANGULARITY_TOLERANCE") == 0) aType = StepDimTol_GTTAngularityTolerance;
+ else if (strcmp(aFirst, "CIRCULAR_RUNOUT_TOLERANCE") == 0) aType = StepDimTol_GTTCircularRunoutTolerance;
+ else if (strcmp(aFirst, "COAXIALITY_TOLERANCE") == 0) aType = StepDimTol_GTTCoaxialityTolerance;
+ else if (strcmp(aFirst, "CONCENTRICITY_TOLERANCE") == 0) aType = StepDimTol_GTTConcentricityTolerance;
+ else if (strcmp(aFirst, "CYLINDRICITY_TOLERANCE") == 0) aType = StepDimTol_GTTCylindricityTolerance;
+ else if (strcmp(aFirst, "FLATNESS_TOLERANCE") == 0) aType = StepDimTol_GTTFlatnessTolerance;
+ else if (strcmp(aLast, "LINE_PROFILE_TOLERANCE") == 0) aType = StepDimTol_GTTLineProfileTolerance;
+ else if (strcmp(aLast, "PARALLELISM_TOLERANCE") == 0) aType = StepDimTol_GTTParallelismTolerance;
+ else if (strcmp(aLast, "PERPENDICULARITY_TOLERANCE") == 0) aType = StepDimTol_GTTPerpendicularityTolerance;
+ else if (strcmp(aLast, "POSITION_TOLERANCE") == 0) aType = StepDimTol_GTTPositionTolerance;
+ else if (strcmp(aLast, "ROUNDNESS_TOLERANCE") == 0) aType = StepDimTol_GTTRoundnessTolerance;
+ else if (strcmp(aLast, "STRAIGHTNESS_TOLERANCE") == 0) aType = StepDimTol_GTTStraightnessTolerance;
+ else if (strcmp(aLast, "SURFACE_PROFILE_TOLERANCE") == 0) aType = StepDimTol_GTTSurfaceProfileTolerance;
+ else if (strcmp(aLast, "SYMMETRY_TOLERANCE") == 0) aType = StepDimTol_GTTSymmetryTolerance;
+ else if (strcmp(aLast, "TOTAL_RUNOUT_TOLERANCE") == 0) aType = StepDimTol_GTTTotalRunoutTolerance;
+ else ach->AddFail("The type of geometric tolerance is not supported");
+
+ // Initialize entity
+ ent->Init(aName, aDescription, aMagnitude, aTolerancedShapeAspect, aGTWM, aType);
+
+}
+
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWGeoTolAndGeoTolWthMod::WriteStep
+ (StepData_StepWriter& SW,
+ const Handle(StepDimTol_GeoTolAndGeoTolWthMod)& ent) const
+{
+ StepDimTol_GeometricToleranceType aType = ent->GetToleranceType();
+ if (aType == StepDimTol_GTTAngularityTolerance)
+ SW.StartEntity("ANGULARITY_TOLERANCE");
+ else if (aType == StepDimTol_GTTCircularRunoutTolerance)
+ SW.StartEntity("CIRCULAR_RUNOUT_TOLERANCE");
+ else if (aType == StepDimTol_GTTCoaxialityTolerance)
+ SW.StartEntity("COAXIALITY_TOLERANCE");
+ else if (aType == StepDimTol_GTTConcentricityTolerance)
+ SW.StartEntity("CONCENTRICITY_TOLERANCE");
+ else if (aType == StepDimTol_GTTCylindricityTolerance)
+ SW.StartEntity("CYLINDRICITY_TOLERANCE");
+ else if (aType == StepDimTol_GTTFlatnessTolerance)
+ SW.StartEntity("FLATNESS_TOLERANCE");
+
+ SW.StartEntity("GEOMETRIC_TOLERANCE");
+ SW.Send(ent->Name());
+ SW.Send(ent->Description());
+ SW.Send(ent->Magnitude());
+ SW.Send(ent->TolerancedShapeAspect().Value());
+ SW.StartEntity("GEOMETRIC_TOLERANCE_WITH_MODIFIERS");
+ SW.OpenSub();
+ Handle(StepDimTol_GeometricToleranceWithModifiers) aGTWM = ent->GetGeometricToleranceWithModifiers();
+ for (Standard_Integer i = 1; i <= aGTWM->NbModifiers(); i++) {
+ switch (aGTWM->ModifierValue(i)) {
+ case StepDimTol_GTMAnyCrossSection: SW.SendEnum (".ANY_CROSS_SECTION."); break;
+ case StepDimTol_GTMCommonZone: SW.SendEnum (".COMMON_ZONE."); break;
+ case StepDimTol_GTMEachRadialElement: SW.SendEnum (".EACH_RADIAL_ELEMENT."); break;
+ case StepDimTol_GTMFreeState: SW.SendEnum (".FREE_STATE."); break;
+ case StepDimTol_GTMLeastMaterialRequirement: SW.SendEnum (".LEAST_MATERIAL_REQUIREMENT."); break;
+ case StepDimTol_GTMLineElement: SW.SendEnum (".LINE_ELEMENT."); break;
+ case StepDimTol_GTMMajorDiameter: SW.SendEnum (".MAJOR_DIAMETER."); break;
+ case StepDimTol_GTMMaximumMaterialRequirement: SW.SendEnum (".MAXIMUM_MATERIAL_REQUIREMENT."); break;
+ case StepDimTol_GTMMinorDiameter: SW.SendEnum (".MINOR_DIAMETER."); break;
+ case StepDimTol_GTMNotConvex: SW.SendEnum (".NOT_CONVEX."); break;
+ case StepDimTol_GTMPitchDiameter: SW.SendEnum (".PITCH_DIAMETER."); break;
+ case StepDimTol_GTMReciprocityRequirement: SW.SendEnum (".RECIPROCITY_REQUIREMENT."); break;
+ case StepDimTol_GTMSeparateRequirement: SW.SendEnum (".SEPARATE_REQUIREMENT."); break;
+ case StepDimTol_GTMStatisticalTolerance: SW.SendEnum (".STATISTICAL_TOLERANCE."); break;
+ case StepDimTol_GTMTangentPlane: SW.SendEnum (".TANGENT_PLANE."); break;
+ }
+ }
+ SW.CloseSub();
+ if (aType == StepDimTol_GTTLineProfileTolerance)
+ SW.StartEntity("LINE_PROFILE_TOLERANCE");
+ else if (aType == StepDimTol_GTTParallelismTolerance)
+ SW.StartEntity("PARALLELISM_TOLERANCE");
+ else if (aType == StepDimTol_GTTPerpendicularityTolerance)
+ SW.StartEntity("PERPENDICULARITY_TOLERANCE");
+ else if (aType == StepDimTol_GTTPositionTolerance)
+ SW.StartEntity("POSITION_TOLERANCE");
+ else if (aType == StepDimTol_GTTRoundnessTolerance)
+ SW.StartEntity("ROUNDNESS_TOLERANCE");
+ else if (aType == StepDimTol_GTTStraightnessTolerance)
+ SW.StartEntity("STRAIGHTNESS_TOLERANCE");
+ else if (aType == StepDimTol_GTTSurfaceProfileTolerance)
+ SW.StartEntity("SURFACE_PROFILE_TOLERANCE");
+ else if (aType == StepDimTol_GTTSymmetryTolerance)
+ SW.StartEntity("SYMMETRY_TOLERANCE");
+ else if (aType == StepDimTol_GTTTotalRunoutTolerance)
+ SW.StartEntity("TOTAL_RUNOUT_TOLERANCE");
+}
+
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWGeoTolAndGeoTolWthMod::Share
+ (const Handle(StepDimTol_GeoTolAndGeoTolWthMod)& ent,
+ Interface_EntityIterator& iter) const
+{
+ // Own fields of GeometricTolerance
+ iter.AddItem (ent->Magnitude());
+ iter.AddItem (ent->TolerancedShapeAspect().Value());
+}
--- /dev/null
+// Created on: 2015-08-10
+// Created by: Irina KRYLOVA
+// 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 _RWStepDimTol_RWGeoTolAndGeoTolWthMod_HeaderFile
+#define _RWStepDimTol_RWGeoTolAndGeoTolWthMod_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+class StepData_StepReaderData;
+class Interface_Check;
+class StepDimTol_GeoTolAndGeoTolWthMod;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write Module for GeoTolAndGeoTolWthMod
+class RWStepDimTol_RWGeoTolAndGeoTolWthMod
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ Standard_EXPORT RWStepDimTol_RWGeoTolAndGeoTolWthMod();
+
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepDimTol_GeoTolAndGeoTolWthMod)& ent) const;
+
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepDimTol_GeoTolAndGeoTolWthMod)& ent) const;
+
+ Standard_EXPORT void Share (const Handle(StepDimTol_GeoTolAndGeoTolWthMod)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepDimTol_RWGeoTolAndGeoTolWthMod_HeaderFile
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_GeometricTolerance.hxx>
-#include <StepRepr_ShapeAspect.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
//=======================================================================
//function : RWStepDimTol_RWGeometricTolerance
Handle(StepBasic_MeasureWithUnit) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aMagnitude);
- Handle(StepRepr_ShapeAspect) aTolerancedShapeAspect;
- data->ReadEntity (num, 4, "toleranced_shape_aspect", ach, STANDARD_TYPE(StepRepr_ShapeAspect), aTolerancedShapeAspect);
+ StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
+ data->ReadEntity (num, 4, "toleranced_shape_aspect", ach, aTolerancedShapeAspect);
// Initialize entity
ent->Init(aName,
SW.Send (ent->Magnitude());
- SW.Send (ent->TolerancedShapeAspect());
+ SW.Send (ent->TolerancedShapeAspect().Value());
}
//=======================================================================
iter.AddItem (ent->Magnitude());
- iter.AddItem (ent->TolerancedShapeAspect());
+ iter.AddItem (ent->TolerancedShapeAspect().Value());
}
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_DatumReference.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
#include <StepDimTol_GeometricToleranceWithDatumReference.hxx>
-#include <StepDimTol_HArray1OfDatumReference.hxx>
-#include <StepRepr_ShapeAspect.hxx>
+#include <StepDimTol_HArray1OfDatumSystemOrReference.hxx>
//=======================================================================
//function : RWStepDimTol_RWGeometricToleranceWithDatumReference
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
- Handle(StepRepr_ShapeAspect) aGeometricTolerance_TolerancedShapeAspect;
- data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, STANDARD_TYPE(StepRepr_ShapeAspect), aGeometricTolerance_TolerancedShapeAspect);
+ StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
+ data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
// Own fields of GeometricToleranceWithDatumReference
- Handle(StepDimTol_HArray1OfDatumReference) aDatumSystem;
+ Handle(StepDimTol_HArray1OfDatumSystemOrReference) aDatumSystem;
Standard_Integer sub5 = 0;
if ( data->ReadSubList (num, 5, "datum_system", ach, sub5) ) {
Standard_Integer nb0 = data->NbParams(sub5);
- aDatumSystem = new StepDimTol_HArray1OfDatumReference (1, nb0);
+ aDatumSystem = new StepDimTol_HArray1OfDatumSystemOrReference (1, nb0);
Standard_Integer num2 = sub5;
for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
- Handle(StepDimTol_DatumReference) anIt0;
- data->ReadEntity (num2, i0, "datum_reference", ach, STANDARD_TYPE(StepDimTol_DatumReference), anIt0);
+ StepDimTol_DatumSystemOrReference anIt0;
+ data->ReadEntity (num2, i0, "datum_system_or_reference", ach, anIt0);
aDatumSystem->SetValue(i0, anIt0);
}
}
SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
- SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
// Own fields of GeometricToleranceWithDatumReference
SW.OpenSub();
- for (Standard_Integer i4=1; i4 <= ent->DatumSystem()->Length(); i4++ ) {
- Handle(StepDimTol_DatumReference) Var0 = ent->DatumSystem()->Value(i4);
- SW.Send (Var0);
+ for (Standard_Integer i4=1; i4 <= ent->DatumSystemAP242()->Length(); i4++ ) {
+ StepDimTol_DatumSystemOrReference Var0 = ent->DatumSystemAP242()->Value(i4);
+ SW.Send (Var0.Value());
}
SW.CloseSub();
}
iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
- iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
// Own fields of GeometricToleranceWithDatumReference
- for (Standard_Integer i3=1; i3 <= ent->DatumSystem()->Length(); i3++ ) {
- Handle(StepDimTol_DatumReference) Var0 = ent->DatumSystem()->Value(i3);
- iter.AddItem (Var0);
+ for (Standard_Integer i3=1; i3 <= ent->DatumSystemAP242()->Length(); i3++ ) {
+ StepDimTol_DatumSystemOrReference Var0 = ent->DatumSystemAP242()->Value(i3);
+ iter.AddItem (Var0.Value());
}
}
--- /dev/null
+// Created on: 2015-07-07
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepDimTol_RWGeometricToleranceWithDefinedAreaUnit.hxx>
+
+#include <Interface_Check.hxx>
+#include <Interface_EntityIterator.hxx>
+#include <StepBasic_LengthMeasureWithUnit.hxx>
+#include <StepBasic_MeasureWithUnit.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepDimTol_AreaUnitType.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
+#include <StepDimTol_GeometricToleranceWithDefinedAreaUnit.hxx>
+
+//=======================================================================
+//function : RWStepDimTol_RWGeometricToleranceWithDefinedAreaUnit
+//purpose :
+//=======================================================================
+
+RWStepDimTol_RWGeometricToleranceWithDefinedAreaUnit::RWStepDimTol_RWGeometricToleranceWithDefinedAreaUnit ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWGeometricToleranceWithDefinedAreaUnit::
+ ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepDimTol_GeometricToleranceWithDefinedAreaUnit) &ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num, 7, ach, "geometric_tolerance_with_defined_area_unit") ) return;
+
+ // inherited fields from GeometricTolerance
+
+ Handle(TCollection_HAsciiString) aName;
+ data->ReadString (num, 1, "geometric_tolerance.name", ach, aName);
+
+ Handle(TCollection_HAsciiString) aDescription;
+ data->ReadString (num, 2, "geometric_tolerance.description", ach, aDescription);
+
+ Handle(StepBasic_MeasureWithUnit) aMagnitude;
+ data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aMagnitude);
+
+ StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
+ data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aTolerancedShapeAspect);
+
+ // inherited fields from GeometricToleranceWithDefinedUnit
+
+ Handle(StepBasic_LengthMeasureWithUnit) anUnitSize;
+ data->ReadEntity (num, 5, "geometric_tolerance_with_defined_unit.unit_size", ach, STANDARD_TYPE(StepBasic_LengthMeasureWithUnit), anUnitSize);
+
+ // own fields of GeometricToleranceWithDefinedAreaUnit
+ StepDimTol_AreaUnitType aType = StepDimTol_Circular;
+ if (data->ParamType (num, 6) == Interface_ParamEnum) {
+ Standard_CString text = data->ParamCValue(num, 6);
+ if (strcmp(text, ".CIRCULAR.")==0) aType = StepDimTol_Circular;
+ else if (strcmp(text, ".RECTANGULAR.")==0) aType = StepDimTol_Rectangular;
+ else if (strcmp(text, ".SQUARE.")==0) aType = StepDimTol_Square;
+ else ach->AddFail("Parameter #6 (area_type) has not allowed value");
+ }
+ else ach->AddFail("Parameter #6 (area_type) is not enumerations");
+
+ Handle(StepBasic_LengthMeasureWithUnit) aSecondUnitSize;
+ Standard_Boolean hasSecondUnitSize = data->IsParamDefined(num, 7);
+ if (hasSecondUnitSize)
+ data->ReadEntity(num, 7, "second_unit_size", ach, STANDARD_TYPE(StepBasic_LengthMeasureWithUnit), aSecondUnitSize);
+
+ // Initialize entity
+ ent->Init(aName,
+ aDescription,
+ aMagnitude,
+ aTolerancedShapeAspect,
+ anUnitSize,
+ aType,
+ hasSecondUnitSize,
+ aSecondUnitSize);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWGeometricToleranceWithDefinedAreaUnit::
+ WriteStep (StepData_StepWriter& SW,
+ const Handle(StepDimTol_GeometricToleranceWithDefinedAreaUnit) &ent) const
+{
+
+ // inherited fields from GeometricTolerance
+
+ SW.Send (ent->Name());
+
+ SW.Send (ent->Description());
+
+ SW.Send (ent->Magnitude());
+
+ SW.Send (ent->TolerancedShapeAspect().Value());
+
+ // inherited fields from GeometricToleranceWithDefinedUnit
+
+ SW.Send (ent->UnitSize());
+
+ // own fields of GeometricToleranceWithDefinedAreaUnit
+
+ switch (ent->AreaType()) {
+ case StepDimTol_Circular: SW.SendEnum (".CIRCULAR."); break;
+ case StepDimTol_Rectangular: SW.SendEnum (".RECTANGULAR."); break;
+ case StepDimTol_Square: SW.SendEnum (".SQUARE."); break;
+ }
+
+ if (ent->HasSecondUnitSize())
+ SW.Send (ent->SecondUnitSize());
+ else
+ SW.SendUndef();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWGeometricToleranceWithDefinedAreaUnit::
+ Share (const Handle(StepDimTol_GeometricToleranceWithDefinedAreaUnit) &ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // inherited fields from GeometricTolerance
+
+ iter.AddItem (ent->Magnitude());
+
+ iter.AddItem (ent->TolerancedShapeAspect().Value());
+}
--- /dev/null
+// Created on: 2015-07-07
+// Created by: Irina KRYLOVA
+// 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 _RWStepDimTol_RWGeometricToleranceWithDefinedAreaUnit_HeaderFile
+#define _RWStepDimTol_RWGeometricToleranceWithDefinedAreaUnit_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepDimTol_GeometricToleranceWithDefinedAreaUnit;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write tool for GeometricToleranceWithDefinedAreaUnit
+class RWStepDimTol_RWGeometricToleranceWithDefinedAreaUnit
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ //! Empty constructor
+ Standard_EXPORT RWStepDimTol_RWGeometricToleranceWithDefinedAreaUnit();
+
+ //! Reads GeometricToleranceWithDefinedAreaUnit
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepDimTol_GeometricToleranceWithDefinedAreaUnit)& ent) const;
+
+ //! Writes GeometricToleranceWithDefinedAreaUnit
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepDimTol_GeometricToleranceWithDefinedAreaUnit)& ent) const;
+
+ //! Fills data for graph (shared items)
+ Standard_EXPORT void Share (const Handle(StepDimTol_GeometricToleranceWithDefinedAreaUnit)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepDimTol_RWGeometricToleranceWithDefinedAreaUnit_HeaderFile
--- /dev/null
+// Created on: 2015-07-07
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepDimTol_RWGeometricToleranceWithDefinedUnit.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepBasic_LengthMeasureWithUnit.hxx>
+#include <StepBasic_MeasureWithUnit.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
+#include <StepDimTol_GeometricToleranceWithDefinedUnit.hxx>
+
+//=======================================================================
+//function : RWStepDimTol_RWGeometricToleranceWithDefinedUnit
+//purpose :
+//=======================================================================
+
+RWStepDimTol_RWGeometricToleranceWithDefinedUnit::RWStepDimTol_RWGeometricToleranceWithDefinedUnit ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWGeometricToleranceWithDefinedUnit::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepDimTol_GeometricToleranceWithDefinedUnit) &ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num, 5, ach, "geometric_tolerance_with_defined_unit") ) return;
+
+ // inherited fields from GeometricTolerance
+
+ Handle(TCollection_HAsciiString) aName;
+ data->ReadString (num, 1, "geometric_tolerance.name", ach, aName);
+
+ Handle(TCollection_HAsciiString) aDescription;
+ data->ReadString (num, 2, "geometric_tolerance.description", ach, aDescription);
+
+ Handle(StepBasic_MeasureWithUnit) aMagnitude;
+ data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aMagnitude);
+
+ StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
+ data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aTolerancedShapeAspect);
+
+ // own fields of GeometricToleranceWithDefinedUnit
+
+ Handle(StepBasic_LengthMeasureWithUnit) anUnitSize;
+ data->ReadEntity (num, 5, "unit_size", ach, STANDARD_TYPE(StepBasic_LengthMeasureWithUnit), anUnitSize);
+
+ // Initialize entity
+ ent->Init(aName,
+ aDescription,
+ aMagnitude,
+ aTolerancedShapeAspect,
+ anUnitSize);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWGeometricToleranceWithDefinedUnit::
+ WriteStep (StepData_StepWriter& SW,
+ const Handle(StepDimTol_GeometricToleranceWithDefinedUnit) &ent) const
+{
+
+ // inherited fields from GeometricTolerance
+
+ SW.Send (ent->Name());
+
+ SW.Send (ent->Description());
+
+ SW.Send (ent->Magnitude());
+
+ SW.Send (ent->TolerancedShapeAspect().Value());
+
+ // own fields of GeometricToleranceWithDefinedUnit
+
+ SW.Send (ent->UnitSize());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWGeometricToleranceWithDefinedUnit::Share (const Handle(StepDimTol_GeometricToleranceWithDefinedUnit) &ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // inherited fields from GeometricTolerance
+
+ iter.AddItem (ent->Magnitude());
+
+ iter.AddItem (ent->TolerancedShapeAspect().Value());
+}
--- /dev/null
+// Created on: 2015-07-07
+// Created by: Irina KRYLOVA
+// 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 _RWStepDimTol_RWGeometricToleranceWithDefinedUnit_HeaderFile
+#define _RWStepDimTol_RWGeometricToleranceWithDefinedUnit_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepDimTol_GeometricToleranceWithDefinedUnit;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write tool for GeometricToleranceWithDefinedUnit
+class RWStepDimTol_RWGeometricToleranceWithDefinedUnit
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ //! Empty constructor
+ Standard_EXPORT RWStepDimTol_RWGeometricToleranceWithDefinedUnit();
+
+ //! Reads GeometricToleranceWithDefinedUnit
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepDimTol_GeometricToleranceWithDefinedUnit)& ent) const;
+
+ //! Writes GeometricToleranceWithDefinedUnit
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepDimTol_GeometricToleranceWithDefinedUnit)& ent) const;
+
+ //! Fills data for graph (shared items)
+ Standard_EXPORT void Share (const Handle(StepDimTol_GeometricToleranceWithDefinedUnit)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepDimTol_RWGeometricToleranceWithDefinedUnit_HeaderFile
--- /dev/null
+// Created on: 2015-07-07
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepDimTol_RWGeometricToleranceWithMaximumTolerance.hxx>
+
+#include <Interface_Check.hxx>
+#include <Interface_EntityIterator.hxx>
+#include <StepBasic_LengthMeasureWithUnit.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepDimTol_GeometricToleranceModifier.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
+#include <StepDimTol_GeometricToleranceWithMaximumTolerance.hxx>
+#include <StepDimTol_HArray1OfGeometricToleranceModifier.hxx>
+
+//=======================================================================
+//function : RWStepDimTol_RWGeometricTolerance
+//purpose :
+//=======================================================================
+
+RWStepDimTol_RWGeometricToleranceWithMaximumTolerance::RWStepDimTol_RWGeometricToleranceWithMaximumTolerance ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWGeometricToleranceWithMaximumTolerance::
+ ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepDimTol_GeometricToleranceWithMaximumTolerance) &ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num, 6, ach, "geometric_tolerance_with_modifiers") ) return;
+
+ // inherited fields from GeometricTolerance
+
+ Handle(TCollection_HAsciiString) aName;
+ data->ReadString (num, 1, "geometric_tolerance.name", ach, aName);
+
+ Handle(TCollection_HAsciiString) aDescription;
+ data->ReadString (num, 2, "geometric_tolerance.description", ach, aDescription);
+
+ Handle(StepBasic_MeasureWithUnit) aMagnitude;
+ data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aMagnitude);
+
+ StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
+ data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aTolerancedShapeAspect);
+
+ // inherited fields from GeometricToleranceWithModifiers
+ Handle(StepDimTol_HArray1OfGeometricToleranceModifier) aModifiers;
+ Standard_Integer sub5 = 0;
+ if ( data->ReadSubList (num, 5, "geometric_tolerance_with_modifiers.modifiers", ach, sub5) ) {
+ Standard_Integer nb0 = data->NbParams(sub5);
+ aModifiers = new StepDimTol_HArray1OfGeometricToleranceModifier (1, nb0);
+ Standard_Integer num2 = sub5;
+ for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
+ StepDimTol_GeometricToleranceModifier anIt0 = StepDimTol_GTMMaximumMaterialRequirement;
+ if (data->ParamType (num2, i0) == Interface_ParamEnum) {
+ Standard_CString text = data->ParamCValue(num2, i0);
+ if (strcmp(text, ".ANY_CROSS_SECTION.")==0) anIt0 = StepDimTol_GTMAnyCrossSection;
+ else if (strcmp(text, ".COMMON_ZONE.")==0) anIt0 = StepDimTol_GTMCommonZone;
+ else if (strcmp(text, ".EACH_RADIAL_ELEMENT.")==0) anIt0 = StepDimTol_GTMEachRadialElement;
+ else if (strcmp(text, ".FREE_STATE.")==0) anIt0 = StepDimTol_GTMFreeState;
+ else if (strcmp(text, ".LEAST_MATERIAL_REQUIREMENT.")==0) anIt0 = StepDimTol_GTMLeastMaterialRequirement;
+ else if (strcmp(text, ".LINE_ELEMENT.")==0) anIt0 = StepDimTol_GTMLineElement;
+ else if (strcmp(text, ".MAJOR_DIAMETER.")==0) anIt0 = StepDimTol_GTMMajorDiameter;
+ else if (strcmp(text, ".MAXIMUM_MATERIAL_REQUIREMENT.")==0) anIt0 = StepDimTol_GTMMaximumMaterialRequirement;
+ else if (strcmp(text, ".MINOR_DIAMETER.")==0) anIt0 = StepDimTol_GTMMinorDiameter;
+ else if (strcmp(text, ".NOT_CONVEX.")==0) anIt0 = StepDimTol_GTMNotConvex;
+ else if (strcmp(text, ".PITCH_DIAMETER.")==0) anIt0 = StepDimTol_GTMPitchDiameter;
+ else if (strcmp(text, ".RECIPROCITY_REQUIREMENT.")==0) anIt0 = StepDimTol_GTMReciprocityRequirement;
+ else if (strcmp(text, ".SEPARATE_REQUIREMENT.")==0) anIt0 = StepDimTol_GTMSeparateRequirement;
+ else if (strcmp(text, ".STATISTICAL_TOLERANCE.")==0) anIt0 = StepDimTol_GTMStatisticalTolerance;
+ else if (strcmp(text, ".TANGENT_PLANE.")==0) anIt0 = StepDimTol_GTMTangentPlane;
+ else ach->AddFail("Parameter #5 (modifiers) has not allowed value");
+ }
+ else ach->AddFail("Parameter #5 (modifier) is not set of enumerations");
+ aModifiers->SetValue(i0, anIt0);
+ }
+ }
+
+ // own fields of GeometricToleranceWithMaximumTolerance
+
+ Handle(StepBasic_LengthMeasureWithUnit) aMaximumUpperTolerance;
+ data->ReadEntity (num, 6, "maximum_upper_tolerance", ach, STANDARD_TYPE(StepBasic_LengthMeasureWithUnit), aMaximumUpperTolerance);
+
+ // Initialize entity
+ ent->Init(aName,
+ aDescription,
+ aMagnitude,
+ aTolerancedShapeAspect,
+ aModifiers,
+ aMaximumUpperTolerance);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWGeometricToleranceWithMaximumTolerance::
+ WriteStep (StepData_StepWriter& SW,
+ const Handle(StepDimTol_GeometricToleranceWithMaximumTolerance) &ent) const
+{
+
+ // inherited fields from GeometricTolerance
+
+ SW.Send (ent->Name());
+
+ SW.Send (ent->Description());
+
+ SW.Send (ent->Magnitude());
+
+ SW.Send (ent->TolerancedShapeAspect().Value());
+
+ // inherited fields from GeometricToleranceWithModifiers
+
+ SW.OpenSub();
+ for (Standard_Integer i = 1; i <= ent->NbModifiers(); i++) {
+ switch (ent->ModifierValue(i)) {
+ case StepDimTol_GTMAnyCrossSection: SW.SendEnum (".ANY_CROSS_SECTION."); break;
+ case StepDimTol_GTMCommonZone: SW.SendEnum (".COMMON_ZONE."); break;
+ case StepDimTol_GTMEachRadialElement: SW.SendEnum (".EACH_RADIAL_ELEMENT."); break;
+ case StepDimTol_GTMFreeState: SW.SendEnum (".FREE_STATE."); break;
+ case StepDimTol_GTMLeastMaterialRequirement: SW.SendEnum (".LEAST_MATERIAL_REQUIREMENT."); break;
+ case StepDimTol_GTMLineElement: SW.SendEnum (".LINE_ELEMENT."); break;
+ case StepDimTol_GTMMajorDiameter: SW.SendEnum (".MAJOR_DIAMETER."); break;
+ case StepDimTol_GTMMaximumMaterialRequirement: SW.SendEnum (".MAXIMUM_MATERIAL_REQUIREMENT."); break;
+ case StepDimTol_GTMMinorDiameter: SW.SendEnum (".MINOR_DIAMETER."); break;
+ case StepDimTol_GTMNotConvex: SW.SendEnum (".NOT_CONVEX."); break;
+ case StepDimTol_GTMPitchDiameter: SW.SendEnum (".PITCH_DIAMETER."); break;
+ case StepDimTol_GTMReciprocityRequirement: SW.SendEnum (".RECIPROCITY_REQUIREMENT."); break;
+ case StepDimTol_GTMSeparateRequirement: SW.SendEnum (".SEPARATE_REQUIREMENT."); break;
+ case StepDimTol_GTMStatisticalTolerance: SW.SendEnum (".STATISTICAL_TOLERANCE."); break;
+ case StepDimTol_GTMTangentPlane: SW.SendEnum (".TANGENT_PLANE."); break;
+ }
+ }
+ SW.CloseSub();
+
+ // own fields of GeometricToleranceWithMaximumTolerance
+
+ SW.Send (ent->MaximumUpperTolerance());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWGeometricToleranceWithMaximumTolerance::
+ Share (const Handle(StepDimTol_GeometricToleranceWithMaximumTolerance) &ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // inherited fields from GeometricTolerance
+
+ iter.AddItem (ent->Magnitude());
+
+ iter.AddItem (ent->TolerancedShapeAspect().Value());
+}
--- /dev/null
+// Created on: 2015-07-07
+// Created by: Irina KRYLOVA
+// 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 _RWStepDimTol_RWGeometricToleranceWithMaximumTolerance_HeaderFile
+#define _RWStepDimTol_RWGeometricToleranceWithMaximumTolerance_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepDimTol_GeometricToleranceWithMaximumTolerance;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write tool for GeometricToleranceWithMaximumTolerance
+class RWStepDimTol_RWGeometricToleranceWithMaximumTolerance
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ //! Empty constructor
+ Standard_EXPORT RWStepDimTol_RWGeometricToleranceWithMaximumTolerance();
+
+ //! Reads GeometricToleranceWithMaximumTolerance
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepDimTol_GeometricToleranceWithMaximumTolerance)& ent) const;
+
+ //! Writes GeometricToleranceWithMaximumTolerance
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepDimTol_GeometricToleranceWithMaximumTolerance)& ent) const;
+
+ //! Fills data for graph (shared items)
+ Standard_EXPORT void Share (const Handle(StepDimTol_GeometricToleranceWithMaximumTolerance)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepDimTol_RWGeometricToleranceWithMaximumTolerance_HeaderFile
--- /dev/null
+// Created on: 2015-07-07
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepDimTol_RWGeometricToleranceWithModifiers.hxx>
+
+#include <Interface_Check.hxx>
+#include <Interface_EntityIterator.hxx>
+#include <StepBasic_MeasureWithUnit.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepDimTol_GeometricToleranceModifier.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
+#include <StepDimTol_GeometricToleranceWithModifiers.hxx>
+#include <StepDimTol_HArray1OfGeometricToleranceModifier.hxx>
+
+//=======================================================================
+//function : RWStepDimTol_RWGeometricTolerance
+//purpose :
+//=======================================================================
+
+RWStepDimTol_RWGeometricToleranceWithModifiers::RWStepDimTol_RWGeometricToleranceWithModifiers ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWGeometricToleranceWithModifiers::
+ ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepDimTol_GeometricToleranceWithModifiers) &ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num, 5, ach, "geometric_tolerance_with_modifiers") ) return;
+
+ // inherited fields from GeometricTolerance
+
+ Handle(TCollection_HAsciiString) aName;
+ data->ReadString (num, 1, "geometric_tolerance.name", ach, aName);
+
+ Handle(TCollection_HAsciiString) aDescription;
+ data->ReadString (num, 2, "geometric_tolerance.description", ach, aDescription);
+
+ Handle(StepBasic_MeasureWithUnit) aMagnitude;
+ data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aMagnitude);
+
+ StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
+ data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aTolerancedShapeAspect);
+
+ // own fields of GeometricToleranceWithModifiers
+ Handle(StepDimTol_HArray1OfGeometricToleranceModifier) aModifiers;
+ Standard_Integer sub5 = 0;
+ if ( data->ReadSubList (num, 5, "modifiers", ach, sub5) ) {
+ Standard_Integer nb0 = data->NbParams(sub5);
+ aModifiers = new StepDimTol_HArray1OfGeometricToleranceModifier (1, nb0);
+ Standard_Integer num2 = sub5;
+ for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
+ StepDimTol_GeometricToleranceModifier anIt0 = StepDimTol_GTMMaximumMaterialRequirement;
+ if (data->ParamType (num2, i0) == Interface_ParamEnum) {
+ Standard_CString text = data->ParamCValue(num2, i0);
+ if (strcmp(text, ".ANY_CROSS_SECTION.")==0) anIt0 = StepDimTol_GTMAnyCrossSection;
+ else if (strcmp(text, ".COMMON_ZONE.")==0) anIt0 = StepDimTol_GTMCommonZone;
+ else if (strcmp(text, ".EACH_RADIAL_ELEMENT.")==0) anIt0 = StepDimTol_GTMEachRadialElement;
+ else if (strcmp(text, ".FREE_STATE.")==0) anIt0 = StepDimTol_GTMFreeState;
+ else if (strcmp(text, ".LEAST_MATERIAL_REQUIREMENT.")==0) anIt0 = StepDimTol_GTMLeastMaterialRequirement;
+ else if (strcmp(text, ".LINE_ELEMENT.")==0) anIt0 = StepDimTol_GTMLineElement;
+ else if (strcmp(text, ".MAJOR_DIAMETER.")==0) anIt0 = StepDimTol_GTMMajorDiameter;
+ else if (strcmp(text, ".MAXIMUM_MATERIAL_REQUIREMENT.")==0) anIt0 = StepDimTol_GTMMaximumMaterialRequirement;
+ else if (strcmp(text, ".MINOR_DIAMETER.")==0) anIt0 = StepDimTol_GTMMinorDiameter;
+ else if (strcmp(text, ".NOT_CONVEX.")==0) anIt0 = StepDimTol_GTMNotConvex;
+ else if (strcmp(text, ".PITCH_DIAMETER.")==0) anIt0 = StepDimTol_GTMPitchDiameter;
+ else if (strcmp(text, ".RECIPROCITY_REQUIREMENT.")==0) anIt0 = StepDimTol_GTMReciprocityRequirement;
+ else if (strcmp(text, ".SEPARATE_REQUIREMENT.")==0) anIt0 = StepDimTol_GTMSeparateRequirement;
+ else if (strcmp(text, ".STATISTICAL_TOLERANCE.")==0) anIt0 = StepDimTol_GTMStatisticalTolerance;
+ else if (strcmp(text, ".TANGENT_PLANE.")==0) anIt0 = StepDimTol_GTMTangentPlane;
+ else ach->AddFail("Parameter #5 (modifiers) has not allowed value");
+ }
+ else ach->AddFail("Parameter #5 (modifier) is not set of enumerations");
+ aModifiers->SetValue(i0, anIt0);
+ }
+ }
+
+ // Initialize entity
+ ent->Init(aName,
+ aDescription,
+ aMagnitude,
+ aTolerancedShapeAspect,
+ aModifiers);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWGeometricToleranceWithModifiers::
+ WriteStep (StepData_StepWriter& SW,
+ const Handle(StepDimTol_GeometricToleranceWithModifiers) &ent) const
+{
+
+ // inherited fields from GeometricTolerance
+
+ SW.Send (ent->Name());
+
+ SW.Send (ent->Description());
+
+ SW.Send (ent->Magnitude());
+
+ SW.Send (ent->TolerancedShapeAspect().Value());
+
+ // own fields of GeometricToleranceWithModifiers
+
+ SW.OpenSub();
+ for (Standard_Integer i = 1; i <= ent->NbModifiers(); i++) {
+ switch (ent->ModifierValue(i)) {
+ case StepDimTol_GTMAnyCrossSection: SW.SendEnum (".ANY_CROSS_SECTION."); break;
+ case StepDimTol_GTMCommonZone: SW.SendEnum (".COMMON_ZONE."); break;
+ case StepDimTol_GTMEachRadialElement: SW.SendEnum (".EACH_RADIAL_ELEMENT."); break;
+ case StepDimTol_GTMFreeState: SW.SendEnum (".FREE_STATE."); break;
+ case StepDimTol_GTMLeastMaterialRequirement: SW.SendEnum (".LEAST_MATERIAL_REQUIREMENT."); break;
+ case StepDimTol_GTMLineElement: SW.SendEnum (".LINE_ELEMENT."); break;
+ case StepDimTol_GTMMajorDiameter: SW.SendEnum (".MAJOR_DIAMETER."); break;
+ case StepDimTol_GTMMaximumMaterialRequirement: SW.SendEnum (".MAXIMUM_MATERIAL_REQUIREMENT."); break;
+ case StepDimTol_GTMMinorDiameter: SW.SendEnum (".MINOR_DIAMETER."); break;
+ case StepDimTol_GTMNotConvex: SW.SendEnum (".NOT_CONVEX."); break;
+ case StepDimTol_GTMPitchDiameter: SW.SendEnum (".PITCH_DIAMETER."); break;
+ case StepDimTol_GTMReciprocityRequirement: SW.SendEnum (".RECIPROCITY_REQUIREMENT."); break;
+ case StepDimTol_GTMSeparateRequirement: SW.SendEnum (".SEPARATE_REQUIREMENT."); break;
+ case StepDimTol_GTMStatisticalTolerance: SW.SendEnum (".STATISTICAL_TOLERANCE."); break;
+ case StepDimTol_GTMTangentPlane: SW.SendEnum (".TANGENT_PLANE."); break;
+ }
+ }
+ SW.CloseSub();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWGeometricToleranceWithModifiers::
+ Share (const Handle(StepDimTol_GeometricToleranceWithModifiers) &ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // inherited fields from GeometricTolerance
+
+ iter.AddItem (ent->Magnitude());
+
+ iter.AddItem (ent->TolerancedShapeAspect().Value());
+}
--- /dev/null
+// Created on: 2015-07-07
+// Created by: Irina KRYLOVA
+// 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 _RWStepDimTol_RWGeometricToleranceWithModifiers_HeaderFile
+#define _RWStepDimTol_RWGeometricToleranceWithModifiers_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepDimTol_GeometricToleranceWithModifiers;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write tool for GeometricToleranceWithModifiers
+class RWStepDimTol_RWGeometricToleranceWithModifiers
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ //! Empty constructor
+ Standard_EXPORT RWStepDimTol_RWGeometricToleranceWithModifiers();
+
+ //! Reads GeometricToleranceWithModifiers
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepDimTol_GeometricToleranceWithModifiers)& ent) const;
+
+ //! Writes GeometricToleranceWithModifiers
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepDimTol_GeometricToleranceWithModifiers)& ent) const;
+
+ //! Fills data for graph (shared items)
+ Standard_EXPORT void Share (const Handle(StepDimTol_GeometricToleranceWithModifiers)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepDimTol_RWGeometricToleranceWithModifiers_HeaderFile
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
#include <StepDimTol_LineProfileTolerance.hxx>
-#include <StepRepr_ShapeAspect.hxx>
//=======================================================================
//function : RWStepDimTol_RWLineProfileTolerance
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
- Handle(StepRepr_ShapeAspect) aGeometricTolerance_TolerancedShapeAspect;
- data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, STANDARD_TYPE(StepRepr_ShapeAspect), aGeometricTolerance_TolerancedShapeAspect);
+ StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
+ data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
// Initialize entity
ent->Init(aGeometricTolerance_Name,
SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
- SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
}
//=======================================================================
iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
- iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
}
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
#include <StepDimTol_ModifiedGeometricTolerance.hxx>
-#include <StepRepr_ShapeAspect.hxx>
//=======================================================================
//function : RWStepDimTol_RWModifiedGeometricTolerance
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
- Handle(StepRepr_ShapeAspect) aGeometricTolerance_TolerancedShapeAspect;
- data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, STANDARD_TYPE(StepRepr_ShapeAspect), aGeometricTolerance_TolerancedShapeAspect);
+ StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
+ data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
// Own fields of ModifiedGeometricTolerance
SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
- SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
// Own fields of ModifiedGeometricTolerance
iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
- iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
// Own fields of ModifiedGeometricTolerance
}
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepDimTol_RWNonUniformZoneDefinition.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepRepr_HArray1OfShapeAspect.hxx>
+#include <StepDimTol_NonUniformZoneDefinition.hxx>
+#include <StepDimTol_ToleranceZone.hxx>
+
+//=======================================================================
+//function : RWStepDimTol_RWNonUniformZoneDefinition
+//purpose :
+//=======================================================================
+
+RWStepDimTol_RWNonUniformZoneDefinition::RWStepDimTol_RWNonUniformZoneDefinition ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWNonUniformZoneDefinition::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepDimTol_NonUniformZoneDefinition) &ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,2,ach,"non_uniform_zone_definition") ) return;
+
+ // Inherited fields from ToleranceZoneDefinition
+
+ Handle(StepDimTol_ToleranceZone) aToleranceZone;
+ data->ReadEntity (num, 1, "tolerance_zone_definition.zone", ach, STANDARD_TYPE(StepDimTol_ToleranceZone), aToleranceZone);
+
+ Handle(StepRepr_HArray1OfShapeAspect) anItems;
+ Handle(StepRepr_ShapeAspect) anEnt;
+ Standard_Integer nbSub;
+ if (data->ReadSubList (num,2,"tolerance_zone_definition.boundaries",ach,nbSub)) {
+ Standard_Integer nbElements = data->NbParams(nbSub);
+ anItems = new StepRepr_HArray1OfShapeAspect (1, nbElements);
+ for (Standard_Integer i = 1; i <= nbElements; i++) {
+ if (data->ReadEntity(nbSub, i,"shape_aspect", ach, STANDARD_TYPE(StepRepr_ShapeAspect), anEnt))
+ anItems->SetValue(i, anEnt);
+ }
+ }
+
+ // Initialize entity
+ ent->Init(aToleranceZone,
+ anItems);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWNonUniformZoneDefinition::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepDimTol_NonUniformZoneDefinition) &ent) const
+{
+ // Inherited fields of ToleranceZoneDefinition
+
+ SW.Send (ent->Zone());
+
+ SW.OpenSub();
+ for (Standard_Integer i = 1; i <= ent->NbBoundaries(); i++) {
+ SW.Send(ent->BoundariesValue(i));
+ }
+ SW.CloseSub();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWNonUniformZoneDefinition::Share (const Handle(StepDimTol_NonUniformZoneDefinition) &ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields from ToleranceZoneDefinition
+
+ iter.AddItem (ent->Zone());
+
+ Standard_Integer i, nb = ent->NbBoundaries();
+ for (i = 1; i <= nb; i++)
+ iter.AddItem (ent->BoundariesValue(i));
+}
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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 _RWStepDimTol_RWNonUniformZoneDefinition_HeaderFile
+#define _RWStepDimTol_RWNonUniformZoneDefinition_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepDimTol_NonUniformZoneDefinition;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write tool for NonUniformZoneDefinition
+class RWStepDimTol_RWNonUniformZoneDefinition
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ //! Empty constructor
+ Standard_EXPORT RWStepDimTol_RWNonUniformZoneDefinition();
+
+ //! Reads NonUniformZoneDefinition
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepDimTol_NonUniformZoneDefinition)& ent) const;
+
+ //! Writes NonUniformZoneDefinition
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepDimTol_NonUniformZoneDefinition)& ent) const;
+
+ //! Fills data for graph (shared items)
+ Standard_EXPORT void Share (const Handle(StepDimTol_NonUniformZoneDefinition)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepDimTol_RWNonUniformZoneDefinition_HeaderFile
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_DatumReference.hxx>
-#include <StepDimTol_HArray1OfDatumReference.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
+#include <StepDimTol_HArray1OfDatumSystemOrReference.hxx>
#include <StepDimTol_ParallelismTolerance.hxx>
-#include <StepRepr_ShapeAspect.hxx>
//=======================================================================
//function : RWStepDimTol_RWParallelismTolerance
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
- Handle(StepRepr_ShapeAspect) aGeometricTolerance_TolerancedShapeAspect;
- data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, STANDARD_TYPE(StepRepr_ShapeAspect), aGeometricTolerance_TolerancedShapeAspect);
+ StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
+ data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
// Inherited fields of GeometricToleranceWithDatumReference
- Handle(StepDimTol_HArray1OfDatumReference) aGeometricToleranceWithDatumReference_DatumSystem;
+ Handle(StepDimTol_HArray1OfDatumSystemOrReference) aGeometricToleranceWithDatumReference_DatumSystem;
Standard_Integer sub5 = 0;
if ( data->ReadSubList (num, 5, "geometric_tolerance_with_datum_reference.datum_system", ach, sub5) ) {
Standard_Integer nb0 = data->NbParams(sub5);
- aGeometricToleranceWithDatumReference_DatumSystem = new StepDimTol_HArray1OfDatumReference (1, nb0);
+ aGeometricToleranceWithDatumReference_DatumSystem = new StepDimTol_HArray1OfDatumSystemOrReference (1, nb0);
Standard_Integer num2 = sub5;
for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
- Handle(StepDimTol_DatumReference) anIt0;
- data->ReadEntity (num2, i0, "datum_reference", ach, STANDARD_TYPE(StepDimTol_DatumReference), anIt0);
+ StepDimTol_DatumSystemOrReference anIt0;
+ data->ReadEntity (num2, i0, "datum_system_or_reference", ach, anIt0);
aGeometricToleranceWithDatumReference_DatumSystem->SetValue(i0, anIt0);
}
}
SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
- SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
// Inherited fields of GeometricToleranceWithDatumReference
SW.OpenSub();
- for (Standard_Integer i4=1; i4 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Length(); i4++ ) {
- Handle(StepDimTol_DatumReference) Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Value(i4);
- SW.Send (Var0);
+ for (Standard_Integer i4=1; i4 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Length(); i4++ ) {
+ StepDimTol_DatumSystemOrReference Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Value(i4);
+ SW.Send (Var0.Value());
}
SW.CloseSub();
}
iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
- iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
// Inherited fields of GeometricToleranceWithDatumReference
- for (Standard_Integer i3=1; i3 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Length(); i3++ ) {
- Handle(StepDimTol_DatumReference) Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Value(i3);
- iter.AddItem (Var0);
+ for (Standard_Integer i3=1; i3 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Length(); i3++ ) {
+ StepDimTol_DatumSystemOrReference Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Value(i3);
+ iter.AddItem (Var0.Value());
}
}
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_DatumReference.hxx>
-#include <StepDimTol_HArray1OfDatumReference.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
+#include <StepDimTol_HArray1OfDatumSystemOrReference.hxx>
#include <StepDimTol_PerpendicularityTolerance.hxx>
-#include <StepRepr_ShapeAspect.hxx>
//=======================================================================
//function : RWStepDimTol_RWPerpendicularityTolerance
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
- Handle(StepRepr_ShapeAspect) aGeometricTolerance_TolerancedShapeAspect;
- data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, STANDARD_TYPE(StepRepr_ShapeAspect), aGeometricTolerance_TolerancedShapeAspect);
+ StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
+ data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
// Inherited fields of GeometricToleranceWithDatumReference
- Handle(StepDimTol_HArray1OfDatumReference) aGeometricToleranceWithDatumReference_DatumSystem;
+ Handle(StepDimTol_HArray1OfDatumSystemOrReference) aGeometricToleranceWithDatumReference_DatumSystem;
Standard_Integer sub5 = 0;
if ( data->ReadSubList (num, 5, "geometric_tolerance_with_datum_reference.datum_system", ach, sub5) ) {
Standard_Integer nb0 = data->NbParams(sub5);
- aGeometricToleranceWithDatumReference_DatumSystem = new StepDimTol_HArray1OfDatumReference (1, nb0);
+ aGeometricToleranceWithDatumReference_DatumSystem = new StepDimTol_HArray1OfDatumSystemOrReference (1, nb0);
Standard_Integer num2 = sub5;
for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
- Handle(StepDimTol_DatumReference) anIt0;
- data->ReadEntity (num2, i0, "datum_reference", ach, STANDARD_TYPE(StepDimTol_DatumReference), anIt0);
+ StepDimTol_DatumSystemOrReference anIt0;
+ data->ReadEntity (num2, i0, "datum_system_or_reference", ach, anIt0);
aGeometricToleranceWithDatumReference_DatumSystem->SetValue(i0, anIt0);
}
}
SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
- SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
// Inherited fields of GeometricToleranceWithDatumReference
SW.OpenSub();
- for (Standard_Integer i4=1; i4 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Length(); i4++ ) {
- Handle(StepDimTol_DatumReference) Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Value(i4);
- SW.Send (Var0);
+ for (Standard_Integer i4=1; i4 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Length(); i4++ ) {
+ StepDimTol_DatumSystemOrReference Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Value(i4);
+ SW.Send (Var0.Value());
}
SW.CloseSub();
}
iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
- iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
// Inherited fields of GeometricToleranceWithDatumReference
- for (Standard_Integer i3=1; i3 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Length(); i3++ ) {
- Handle(StepDimTol_DatumReference) Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Value(i3);
- iter.AddItem (Var0);
+ for (Standard_Integer i3=1; i3 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Length(); i3++ ) {
+ StepDimTol_DatumSystemOrReference Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Value(i3);
+ iter.AddItem (Var0.Value());
}
}
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
#include <StepDimTol_PositionTolerance.hxx>
-#include <StepRepr_ShapeAspect.hxx>
//=======================================================================
//function : RWStepDimTol_RWPositionTolerance
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
- Handle(StepRepr_ShapeAspect) aGeometricTolerance_TolerancedShapeAspect;
- data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, STANDARD_TYPE(StepRepr_ShapeAspect), aGeometricTolerance_TolerancedShapeAspect);
+ StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
+ data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
// Initialize entity
ent->Init(aGeometricTolerance_Name,
SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
- SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
}
//=======================================================================
iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
- iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
}
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepDimTol_RWProjectedZoneDefinition.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepBasic_LengthMeasureWithUnit.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepRepr_HArray1OfShapeAspect.hxx>
+#include <StepDimTol_ProjectedZoneDefinition.hxx>
+#include <StepDimTol_ToleranceZone.hxx>
+
+//=======================================================================
+//function : RWStepDimTol_RWProjectedZoneDefinition
+//purpose :
+//=======================================================================
+
+RWStepDimTol_RWProjectedZoneDefinition::RWStepDimTol_RWProjectedZoneDefinition ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWProjectedZoneDefinition::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepDimTol_ProjectedZoneDefinition) &ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,4,ach,"projected_zone_definition") ) return;
+
+ // Inherited fields from ToleranceZoneDefinition
+
+ Handle(StepDimTol_ToleranceZone) aToleranceZone;
+ data->ReadEntity (num, 1, "tolerance_zone_definition.zone", ach, STANDARD_TYPE(StepDimTol_ToleranceZone), aToleranceZone);
+
+ Handle(StepRepr_HArray1OfShapeAspect) anItems;
+ Handle(StepRepr_ShapeAspect) anEnt;
+ Standard_Integer nbSub;
+ if (data->ReadSubList (num,2,"tolerance_zone_definition.boundaries",ach,nbSub)) {
+ Standard_Integer nbElements = data->NbParams(nbSub);
+ anItems = new StepRepr_HArray1OfShapeAspect (1, nbElements);
+ for (Standard_Integer i = 1; i <= nbElements; i++) {
+ if (data->ReadEntity(nbSub, i,"shape_aspect", ach, STANDARD_TYPE(StepRepr_ShapeAspect), anEnt))
+ anItems->SetValue(i, anEnt);
+ }
+ }
+
+ Handle(StepRepr_ShapeAspect) aProjectionEnd;
+ data->ReadEntity(num, 3, "projection_end", ach, STANDARD_TYPE(StepRepr_ShapeAspect), aProjectionEnd);
+
+ Handle(StepBasic_LengthMeasureWithUnit) aProjectionLength;
+ data->ReadEntity(num, 4, "projection_length", ach, STANDARD_TYPE(StepBasic_LengthMeasureWithUnit), aProjectionLength);
+
+ // Initialize entity
+ ent->Init(aToleranceZone,
+ anItems,
+ aProjectionEnd,
+ aProjectionLength);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWProjectedZoneDefinition::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepDimTol_ProjectedZoneDefinition) &ent) const
+{
+ // Inherited fields of ToleranceZoneDefinition
+
+ SW.Send (ent->Zone());
+
+ SW.OpenSub();
+ for (Standard_Integer i = 1; i <= ent->NbBoundaries(); i++) {
+ SW.Send(ent->BoundariesValue(i));
+ }
+ SW.CloseSub();
+
+ // Own fields of ProjectedZoneDefinition
+
+ SW.Send (ent->ProjectionEnd());
+
+ SW.Send (ent->ProjectionLength());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWProjectedZoneDefinition::Share (const Handle(StepDimTol_ProjectedZoneDefinition) &ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields from ToleranceZoneDefinition
+
+ iter.AddItem (ent->Zone());
+
+ Standard_Integer i, nb = ent->NbBoundaries();
+ for (i = 1; i <= nb; i++)
+ iter.AddItem (ent->BoundariesValue(i));
+
+ //Own field of ProjectionZoneDefinition
+ iter.AddItem (ent->ProjectionEnd());
+}
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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 _RWStepDimTol_RWProjectedZoneDefinition_HeaderFile
+#define _RWStepDimTol_RWProjectedZoneDefinition_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepDimTol_ProjectedZoneDefinition;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write tool for ProjectedZoneDefinition
+class RWStepDimTol_RWProjectedZoneDefinition
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ //! Empty constructor
+ Standard_EXPORT RWStepDimTol_RWProjectedZoneDefinition();
+
+ //! Reads ProjectedZoneDefinition
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepDimTol_ProjectedZoneDefinition)& ent) const;
+
+ //! Writes ProjectedZoneDefinition
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepDimTol_ProjectedZoneDefinition)& ent) const;
+
+ //! Fills data for graph (shared items)
+ Standard_EXPORT void Share (const Handle(StepDimTol_ProjectedZoneDefinition)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepDimTol_RWProjectedZoneDefinition_HeaderFile
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
#include <StepDimTol_RoundnessTolerance.hxx>
-#include <StepRepr_ShapeAspect.hxx>
//=======================================================================
//function : RWStepDimTol_RWRoundnessTolerance
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
- Handle(StepRepr_ShapeAspect) aGeometricTolerance_TolerancedShapeAspect;
- data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, STANDARD_TYPE(StepRepr_ShapeAspect), aGeometricTolerance_TolerancedShapeAspect);
+ StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
+ data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
// Initialize entity
ent->Init(aGeometricTolerance_Name,
SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
- SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
}
//=======================================================================
iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
- iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
}
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepDimTol_RWRunoutZoneDefinition.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepRepr_HArray1OfShapeAspect.hxx>
+#include <StepDimTol_RunoutZoneDefinition.hxx>
+#include <StepDimTol_RunoutZoneOrientation.hxx>
+#include <StepDimTol_ToleranceZone.hxx>
+
+//=======================================================================
+//function : RWStepDimTol_RWRunoutZoneDefinition
+//purpose :
+//=======================================================================
+
+RWStepDimTol_RWRunoutZoneDefinition::RWStepDimTol_RWRunoutZoneDefinition ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWRunoutZoneDefinition::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepDimTol_RunoutZoneDefinition) &ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,3,ach,"runout_zone_definition") ) return;
+
+ // inherited fields from ToleranceZoneDefinition
+
+ Handle(StepDimTol_ToleranceZone) aToleranceZone;
+ data->ReadEntity (num, 1, "tolerance_zone_definition.zone", ach, STANDARD_TYPE(StepDimTol_ToleranceZone), aToleranceZone);
+
+ Handle(StepRepr_HArray1OfShapeAspect) anItems;
+ Handle(StepRepr_ShapeAspect) anEnt;
+ Standard_Integer nbSub;
+ if (data->ReadSubList (num,2,"tolerance_zone_definition.boundaries",ach,nbSub)) {
+ Standard_Integer nbElements = data->NbParams(nbSub);
+ anItems = new StepRepr_HArray1OfShapeAspect (1, nbElements);
+ for (Standard_Integer i = 1; i <= nbElements; i++) {
+ if (data->ReadEntity(nbSub, i,"shape_aspect", ach, STANDARD_TYPE(StepRepr_ShapeAspect), anEnt))
+ anItems->SetValue(i, anEnt);
+ }
+ }
+
+ Handle(StepDimTol_RunoutZoneOrientation) anOrientation;
+ data->ReadEntity(num, 3, "orientation", ach, STANDARD_TYPE(StepDimTol_RunoutZoneOrientation), anOrientation);
+
+ // Initialize entity
+ ent->Init(aToleranceZone,
+ anItems,
+ anOrientation);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWRunoutZoneDefinition::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepDimTol_RunoutZoneDefinition) &ent) const
+{
+ // Inherited fields of ToleranceZoneDefinition
+
+ SW.Send (ent->Zone());
+
+ SW.OpenSub();
+ for (Standard_Integer i = 1; i <= ent->NbBoundaries(); i++) {
+ SW.Send(ent->BoundariesValue(i));
+ }
+ SW.CloseSub();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWRunoutZoneDefinition::Share (const Handle(StepDimTol_RunoutZoneDefinition) &ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields from ToleranceZoneDefinition
+
+ iter.AddItem (ent->Zone());
+
+ Standard_Integer i, nb = ent->NbBoundaries();
+ for (i = 1; i <= nb; i++)
+ iter.AddItem (ent->BoundariesValue(i));
+}
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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 _RWStepDimTol_RWRunoutZoneDefinition_HeaderFile
+#define _RWStepDimTol_RWRunoutZoneDefinition_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepDimTol_RunoutZoneDefinition;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write tool for RunoutZoneDefinition
+class RWStepDimTol_RWRunoutZoneDefinition
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ //! Empty constructor
+ Standard_EXPORT RWStepDimTol_RWRunoutZoneDefinition();
+
+ //! Reads RunoutZoneDefinition
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepDimTol_RunoutZoneDefinition)& ent) const;
+
+ //! Writes RunoutZoneDefinition
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepDimTol_RunoutZoneDefinition)& ent) const;
+
+ //! Fills data for graph (shared items)
+ Standard_EXPORT void Share (const Handle(StepDimTol_RunoutZoneDefinition)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepDimTol_RWRunoutZoneDefinition_HeaderFile
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepDimTol_RWRunoutZoneOrientation.hxx>
+
+#include <StepBasic_PlaneAngleMeasureWithUnit.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepDimTol_RunoutZoneOrientation.hxx>
+
+//=======================================================================
+//function : RWStepDimTol_RWRunoutZoneOrientation
+//purpose :
+//=======================================================================
+
+RWStepDimTol_RWRunoutZoneOrientation::RWStepDimTol_RWRunoutZoneOrientation ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWRunoutZoneOrientation::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepDimTol_RunoutZoneOrientation) &ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,1,ach,"runout_zone_orientation") ) return;
+
+ // Own fields of RunoutZoneOrientation
+
+ Handle(StepBasic_PlaneAngleMeasureWithUnit) anAngle;
+ data->ReadEntity (num, 1, "angle", ach, STANDARD_TYPE(StepBasic_PlaneAngleMeasureWithUnit), anAngle);
+
+ // Initialize entity
+ ent->Init(anAngle);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWRunoutZoneOrientation::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepDimTol_RunoutZoneOrientation) &ent) const
+{
+ SW.Send (ent->Angle());
+}
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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 _RWStepDimTol_RWRunoutZoneOrientation_HeaderFile
+#define _RWStepDimTol_RWRunoutZoneOrientation_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepDimTol_RunoutZoneOrientation;
+class StepData_StepWriter;
+
+
+//! Read & Write tool for RunoutZoneOrientation
+class RWStepDimTol_RWRunoutZoneOrientation
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ //! Empty constructor
+ Standard_EXPORT RWStepDimTol_RWRunoutZoneOrientation();
+
+ //! Reads RunoutZoneOrientation
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepDimTol_RunoutZoneOrientation)& ent) const;
+
+ //! Writes RunoutZoneOrientation
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepDimTol_RunoutZoneOrientation)& ent) const;
+
+};
+#endif // _RWStepDimTol_RWRunoutZoneOrientation_HeaderFile
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
#include <StepDimTol_StraightnessTolerance.hxx>
-#include <StepRepr_ShapeAspect.hxx>
//=======================================================================
//function : RWStepDimTol_RWStraightnessTolerance
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
- Handle(StepRepr_ShapeAspect) aGeometricTolerance_TolerancedShapeAspect;
- data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, STANDARD_TYPE(StepRepr_ShapeAspect), aGeometricTolerance_TolerancedShapeAspect);
+ StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
+ data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
// Initialize entity
ent->Init(aGeometricTolerance_Name,
SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
- SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
}
//=======================================================================
iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
- iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
}
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
#include <StepDimTol_SurfaceProfileTolerance.hxx>
-#include <StepRepr_ShapeAspect.hxx>
//=======================================================================
//function : RWStepDimTol_RWSurfaceProfileTolerance
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
- Handle(StepRepr_ShapeAspect) aGeometricTolerance_TolerancedShapeAspect;
- data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, STANDARD_TYPE(StepRepr_ShapeAspect), aGeometricTolerance_TolerancedShapeAspect);
+ StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
+ data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
// Initialize entity
ent->Init(aGeometricTolerance_Name,
SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
- SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
}
//=======================================================================
iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
- iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
}
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_DatumReference.hxx>
-#include <StepDimTol_HArray1OfDatumReference.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
+#include <StepDimTol_HArray1OfDatumSystemOrReference.hxx>
#include <StepDimTol_SymmetryTolerance.hxx>
-#include <StepRepr_ShapeAspect.hxx>
//=======================================================================
//function : RWStepDimTol_RWSymmetryTolerance
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
- Handle(StepRepr_ShapeAspect) aGeometricTolerance_TolerancedShapeAspect;
- data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, STANDARD_TYPE(StepRepr_ShapeAspect), aGeometricTolerance_TolerancedShapeAspect);
+ StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
+ data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
// Inherited fields of GeometricToleranceWithDatumReference
- Handle(StepDimTol_HArray1OfDatumReference) aGeometricToleranceWithDatumReference_DatumSystem;
+ Handle(StepDimTol_HArray1OfDatumSystemOrReference) aGeometricToleranceWithDatumReference_DatumSystem;
Standard_Integer sub5 = 0;
if ( data->ReadSubList (num, 5, "geometric_tolerance_with_datum_reference.datum_system", ach, sub5) ) {
Standard_Integer nb0 = data->NbParams(sub5);
- aGeometricToleranceWithDatumReference_DatumSystem = new StepDimTol_HArray1OfDatumReference (1, nb0);
+ aGeometricToleranceWithDatumReference_DatumSystem = new StepDimTol_HArray1OfDatumSystemOrReference (1, nb0);
Standard_Integer num2 = sub5;
for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
- Handle(StepDimTol_DatumReference) anIt0;
- data->ReadEntity (num2, i0, "datum_reference", ach, STANDARD_TYPE(StepDimTol_DatumReference), anIt0);
+ StepDimTol_DatumSystemOrReference anIt0;
+ data->ReadEntity (num2, i0, "datum_system_or_reference", ach, anIt0);
aGeometricToleranceWithDatumReference_DatumSystem->SetValue(i0, anIt0);
}
}
SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
- SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
// Inherited fields of GeometricToleranceWithDatumReference
SW.OpenSub();
- for (Standard_Integer i4=1; i4 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Length(); i4++ ) {
- Handle(StepDimTol_DatumReference) Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Value(i4);
- SW.Send (Var0);
+ for (Standard_Integer i4=1; i4 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Length(); i4++ ) {
+ StepDimTol_DatumSystemOrReference Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Value(i4);
+ SW.Send (Var0.Value());
}
SW.CloseSub();
}
iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
- iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
// Inherited fields of GeometricToleranceWithDatumReference
- for (Standard_Integer i3=1; i3 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Length(); i3++ ) {
- Handle(StepDimTol_DatumReference) Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Value(i3);
- iter.AddItem (Var0);
+ for (Standard_Integer i3=1; i3 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Length(); i3++ ) {
+ StepDimTol_DatumSystemOrReference Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Value(i3);
+ iter.AddItem (Var0.Value());
}
}
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepDimTol_RWToleranceZone.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepDimTol_HArray1OfToleranceZoneTarget.hxx>
+#include <StepDimTol_ToleranceZone.hxx>
+#include <StepDimTol_ToleranceZoneForm.hxx>
+#include <StepDimTol_ToleranceZoneTarget.hxx>
+#include <StepRepr_ProductDefinitionShape.hxx>
+
+//=======================================================================
+//function : RWStepDimTol_RWToleranceZone
+//purpose :
+//=======================================================================
+
+RWStepDimTol_RWToleranceZone::RWStepDimTol_RWToleranceZone ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWToleranceZone::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepDimTol_ToleranceZone) &ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,6,ach,"tolerance_zone") ) return;
+
+ // Inherited fields of ShapeAspect
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Name;
+ data->ReadString (num, 1, "shape_aspect.name", ach, aShapeAspect_Name);
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Description;
+ if ( data->IsParamDefined (num,2) ) {
+ data->ReadString (num, 2, "shape_aspect.description", ach, aShapeAspect_Description);
+ }
+
+ Handle(StepRepr_ProductDefinitionShape) aShapeAspect_OfShape;
+ data->ReadEntity (num, 3, "shape_aspect.of_shape", ach, STANDARD_TYPE(StepRepr_ProductDefinitionShape), aShapeAspect_OfShape);
+
+ StepData_Logical aShapeAspect_ProductDefinitional;
+ data->ReadLogical (num, 4, "shape_aspect.product_definitional", ach, aShapeAspect_ProductDefinitional);
+
+ // Own fields of ToleranceZone
+
+ Handle(StepDimTol_HArray1OfToleranceZoneTarget) anItems;
+ StepDimTol_ToleranceZoneTarget anEnt;
+ Standard_Integer nbSub;
+ if (data->ReadSubList (num,5,"defining_tolerance",ach,nbSub)) {
+ Standard_Integer nbElements = data->NbParams(nbSub);
+ anItems = new StepDimTol_HArray1OfToleranceZoneTarget (1, nbElements);
+ for (Standard_Integer i = 1; i <= nbElements; i++) {
+ if (data->ReadEntity(nbSub, i,"tolerance_zone_target", ach, anEnt))
+ anItems->SetValue(i, anEnt);
+ }
+ }
+
+ Handle (StepDimTol_ToleranceZoneForm) aForm;
+ data->ReadEntity (num, 6, "form", ach, STANDARD_TYPE(StepDimTol_ToleranceZoneForm), aForm);
+
+ // Initialize entity
+ ent->Init(aShapeAspect_Name,
+ aShapeAspect_Description,
+ aShapeAspect_OfShape,
+ aShapeAspect_ProductDefinitional,
+ anItems,
+ aForm);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWToleranceZone::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepDimTol_ToleranceZone) &ent) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ SW.Send (ent->Name());
+
+ SW.Send (ent->Description());
+
+ SW.Send (ent->OfShape());
+
+ SW.SendLogical (ent->ProductDefinitional());
+
+ // Own fields of ToleranceZone
+
+ SW.OpenSub();
+ for (Standard_Integer i = 1; i <= ent->NbDefiningTolerances(); i++) {
+ SW.Send(ent->DefiningToleranceValue(i).Value());
+ }
+ SW.CloseSub();
+
+ SW.Send (ent->Form());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWToleranceZone::Share (const Handle(StepDimTol_ToleranceZone) &ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ iter.AddItem (ent->OfShape());
+
+ // Own fields of ToleranceZone
+ Standard_Integer i, nb = ent->NbDefiningTolerances();
+ for (i = 1; i <= nb; i++)
+ iter.AddItem (ent->DefiningToleranceValue(i).Value());
+}
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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 _RWStepDimTol_RWToleranceZone_HeaderFile
+#define _RWStepDimTol_RWToleranceZone_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepDimTol_ToleranceZone;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write tool for ToleranceZone
+class RWStepDimTol_RWToleranceZone
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ //! Empty constructor
+ Standard_EXPORT RWStepDimTol_RWToleranceZone();
+
+ //! Reads ToleranceZone
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepDimTol_ToleranceZone)& ent) const;
+
+ //! Writes ToleranceZone
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepDimTol_ToleranceZone)& ent) const;
+
+ //! Fills data for graph (shared items)
+ Standard_EXPORT void Share (const Handle(StepDimTol_ToleranceZone)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepDimTol_RWToleranceZone_HeaderFile
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepDimTol_RWToleranceZoneDefinition.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepRepr_HArray1OfShapeAspect.hxx>
+#include <StepDimTol_ToleranceZone.hxx>
+#include <StepDimTol_ToleranceZoneDefinition.hxx>
+
+//=======================================================================
+//function : RWStepDimTol_RWToleranceZoneDefinition
+//purpose :
+//=======================================================================
+
+RWStepDimTol_RWToleranceZoneDefinition::RWStepDimTol_RWToleranceZoneDefinition ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWToleranceZoneDefinition::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepDimTol_ToleranceZoneDefinition) &ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,2,ach,"tolerance_zone_definition") ) return;
+
+ // Own fields of ToleranceZoneDefinition
+
+ Handle(StepDimTol_ToleranceZone) aToleranceZone;
+ data->ReadEntity (num, 1, "zone", ach, STANDARD_TYPE(StepDimTol_ToleranceZone), aToleranceZone);
+
+ Handle(StepRepr_HArray1OfShapeAspect) anItems;
+ Handle(StepRepr_ShapeAspect) anEnt;
+ Standard_Integer nbSub;
+ if (data->ReadSubList (num,2,"boundaries",ach,nbSub)) {
+ Standard_Integer nbElements = data->NbParams(nbSub);
+ anItems = new StepRepr_HArray1OfShapeAspect (1, nbElements);
+ for (Standard_Integer i = 1; i <= nbElements; i++) {
+ if (data->ReadEntity(nbSub, i,"shape_aspect", ach, STANDARD_TYPE(StepRepr_ShapeAspect), anEnt))
+ anItems->SetValue(i, anEnt);
+ }
+ }
+
+ // Initialize entity
+ ent->Init(aToleranceZone,
+ anItems);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWToleranceZoneDefinition::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepDimTol_ToleranceZoneDefinition) &ent) const
+{
+ // Own fields of ToleranceZoneDefinition
+
+ SW.Send (ent->Zone());
+
+ SW.OpenSub();
+ for (Standard_Integer i = 1; i <= ent->NbBoundaries(); i++) {
+ SW.Send(ent->BoundariesValue(i));
+ }
+ SW.CloseSub();
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWToleranceZoneDefinition::Share (const Handle(StepDimTol_ToleranceZoneDefinition) &ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Own fields of ToleranceZoneDefinition
+
+ iter.AddItem (ent->Zone());
+
+ Standard_Integer i, nb = ent->NbBoundaries();
+ for (i = 1; i <= nb; i++)
+ iter.AddItem (ent->BoundariesValue(i));
+}
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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 _RWStepDimTol_RWToleranceZoneDefinition_HeaderFile
+#define _RWStepDimTol_RWToleranceZoneDefinition_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepDimTol_ToleranceZoneDefinition;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write tool for ToleranceZoneDefinition
+class RWStepDimTol_RWToleranceZoneDefinition
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ //! Empty constructor
+ Standard_EXPORT RWStepDimTol_RWToleranceZoneDefinition();
+
+ //! Reads ToleranceZoneDefinition
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepDimTol_ToleranceZoneDefinition)& ent) const;
+
+ //! Writes ToleranceZoneDefinition
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepDimTol_ToleranceZoneDefinition)& ent) const;
+
+ //! Fills data for graph (shared items)
+ Standard_EXPORT void Share (const Handle(StepDimTol_ToleranceZoneDefinition)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepDimTol_RWToleranceZoneDefinition_HeaderFile
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepDimTol_RWToleranceZoneForm.hxx>
+
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepDimTol_ToleranceZoneForm.hxx>
+
+//=======================================================================
+//function : RWStepDimTol_RWToleranceZoneForm
+//purpose :
+//=======================================================================
+
+RWStepDimTol_RWToleranceZoneForm::RWStepDimTol_RWToleranceZoneForm ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWToleranceZoneForm::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepDimTol_ToleranceZoneForm) &ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,1,ach,"tolerance_zone_form") ) return;
+
+ // Own fields of ToleranceZoneForm
+
+ Handle(TCollection_HAsciiString) aName;
+ data->ReadString (num, 1, "name", ach, aName);
+
+ // Initialize entity
+ ent->Init(aName);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWToleranceZoneForm::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepDimTol_ToleranceZoneForm) &ent) const
+{
+ SW.Send (ent->Name());
+}
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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 _RWStepDimTol_RWToleranceZoneForm_HeaderFile
+#define _RWStepDimTol_RWToleranceZoneForm_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepDimTol_ToleranceZoneForm;
+class StepData_StepWriter;
+
+
+//! Read & Write tool for ToleranceZoneForm
+class RWStepDimTol_RWToleranceZoneForm
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ //! Empty constructor
+ Standard_EXPORT RWStepDimTol_RWToleranceZoneForm();
+
+ //! Reads ToleranceZoneForm
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepDimTol_ToleranceZoneForm)& ent) const;
+
+ //! Writes ToleranceZoneForm
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepDimTol_ToleranceZoneForm)& ent) const;
+
+};
+#endif // _RWStepDimTol_RWToleranceZoneForm_HeaderFile
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_DatumReference.hxx>
-#include <StepDimTol_HArray1OfDatumReference.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
+#include <StepDimTol_HArray1OfDatumSystemOrReference.hxx>
#include <StepDimTol_TotalRunoutTolerance.hxx>
-#include <StepRepr_ShapeAspect.hxx>
//=======================================================================
//function : RWStepDimTol_RWTotalRunoutTolerance
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
- Handle(StepRepr_ShapeAspect) aGeometricTolerance_TolerancedShapeAspect;
- data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, STANDARD_TYPE(StepRepr_ShapeAspect), aGeometricTolerance_TolerancedShapeAspect);
+ StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
+ data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
// Inherited fields of GeometricToleranceWithDatumReference
- Handle(StepDimTol_HArray1OfDatumReference) aGeometricToleranceWithDatumReference_DatumSystem;
+ Handle(StepDimTol_HArray1OfDatumSystemOrReference) aGeometricToleranceWithDatumReference_DatumSystem;
Standard_Integer sub5 = 0;
if ( data->ReadSubList (num, 5, "geometric_tolerance_with_datum_reference.datum_system", ach, sub5) ) {
Standard_Integer nb0 = data->NbParams(sub5);
- aGeometricToleranceWithDatumReference_DatumSystem = new StepDimTol_HArray1OfDatumReference (1, nb0);
+ aGeometricToleranceWithDatumReference_DatumSystem = new StepDimTol_HArray1OfDatumSystemOrReference (1, nb0);
Standard_Integer num2 = sub5;
for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
- Handle(StepDimTol_DatumReference) anIt0;
- data->ReadEntity (num2, i0, "datum_reference", ach, STANDARD_TYPE(StepDimTol_DatumReference), anIt0);
+ StepDimTol_DatumSystemOrReference anIt0;
+ data->ReadEntity (num2, i0, "datum_system_or_reference", ach, anIt0);
aGeometricToleranceWithDatumReference_DatumSystem->SetValue(i0, anIt0);
}
}
SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
- SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
// Inherited fields of GeometricToleranceWithDatumReference
SW.OpenSub();
- for (Standard_Integer i4=1; i4 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Length(); i4++ ) {
- Handle(StepDimTol_DatumReference) Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Value(i4);
- SW.Send (Var0);
+ for (Standard_Integer i4=1; i4 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Length(); i4++ ) {
+ StepDimTol_DatumSystemOrReference Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Value(i4);
+ SW.Send (Var0.Value());
}
SW.CloseSub();
}
iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
- iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
+ iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
// Inherited fields of GeometricToleranceWithDatumReference
- for (Standard_Integer i3=1; i3 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Length(); i3++ ) {
- Handle(StepDimTol_DatumReference) Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystem()->Value(i3);
- iter.AddItem (Var0);
+ for (Standard_Integer i3=1; i3 <= ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Length(); i3++ ) {
+ StepDimTol_DatumSystemOrReference Var0 = ent->StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242()->Value(i3);
+ iter.AddItem (Var0.Value());
}
}
--- /dev/null
+// Created on: 2015-07-07
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepDimTol_RWUnequallyDisposedGeometricTolerance.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepBasic_LengthMeasureWithUnit.hxx>
+#include <StepBasic_MeasureWithUnit.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
+#include <StepDimTol_UnequallyDisposedGeometricTolerance.hxx>
+
+//=======================================================================
+//function : RWStepDimTol_RWUnequallyDisposedGeometricTolerance
+//purpose :
+//=======================================================================
+
+RWStepDimTol_RWUnequallyDisposedGeometricTolerance::RWStepDimTol_RWUnequallyDisposedGeometricTolerance ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWUnequallyDisposedGeometricTolerance::
+ ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepDimTol_UnequallyDisposedGeometricTolerance) &ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num, 5, ach, "unequally_disposed_geometric_tolerance") ) return;
+
+ // inherited from GeometricTolerance
+
+ Handle(TCollection_HAsciiString) aName;
+ data->ReadString (num, 1, "geometric_tolerance.name", ach, aName);
+
+ Handle(TCollection_HAsciiString) aDescription;
+ data->ReadString (num, 2, "geometric_tolerance.description", ach, aDescription);
+
+ Handle(StepBasic_MeasureWithUnit) aMagnitude;
+ data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aMagnitude);
+
+ StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
+ data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aTolerancedShapeAspect);
+
+ // own fields of UnequallyDisposedGeometricTolerance
+
+ Handle(StepBasic_LengthMeasureWithUnit) aDisplacement;
+ data->ReadEntity (num, 5, "displacement", ach, STANDARD_TYPE(StepBasic_LengthMeasureWithUnit), aDisplacement);
+
+ // Initialize entity
+ ent->Init(aName,
+ aDescription,
+ aMagnitude,
+ aTolerancedShapeAspect,
+ aDisplacement);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWUnequallyDisposedGeometricTolerance::
+ WriteStep (StepData_StepWriter& SW,
+ const Handle(StepDimTol_UnequallyDisposedGeometricTolerance) &ent) const
+{
+
+ // Own fields of GeometricTolerance
+
+ SW.Send (ent->Name());
+
+ SW.Send (ent->Description());
+
+ SW.Send (ent->Magnitude());
+
+ SW.Send (ent->TolerancedShapeAspect().Value());
+
+ SW.Send (ent->Displacement());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepDimTol_RWUnequallyDisposedGeometricTolerance::
+ Share (const Handle(StepDimTol_UnequallyDisposedGeometricTolerance) &ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Own fields of GeometricTolerance
+
+ iter.AddItem (ent->Magnitude());
+
+ iter.AddItem (ent->TolerancedShapeAspect().Value());
+}
--- /dev/null
+// Created on: 2015-07-07
+// Created by: Irina KRYLOVA
+// 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 _RWStepDimTol_RWUnequallyDisposedGeometricTolerance_HeaderFile
+#define _RWStepDimTol_RWUnequallyDisposedGeometricTolerance_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepDimTol_UnequallyDisposedGeometricTolerance;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write tool for UnequallyDisposedGeometricTolerance
+class RWStepDimTol_RWUnequallyDisposedGeometricTolerance
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ //! Empty constructor
+ Standard_EXPORT RWStepDimTol_RWUnequallyDisposedGeometricTolerance();
+
+ //! Reads UnequallyDisposedGeometricTolerance
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepDimTol_UnequallyDisposedGeometricTolerance)& ent) const;
+
+ //! Writes UnequallyDisposedGeometricTolerance
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepDimTol_UnequallyDisposedGeometricTolerance)& ent) const;
+
+ //! Fills data for graph (shared items)
+ Standard_EXPORT void Share (const Handle(StepDimTol_UnequallyDisposedGeometricTolerance)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepDimTol_RWUnequallyDisposedGeometricTolerance_HeaderFile
+RWStepRepr_RWAllAroundShapeAspect.cxx
+RWStepRepr_RWAllAroundShapeAspect.hxx
+RWStepRepr_RWApex.cxx
+RWStepRepr_RWApex.hxx
RWStepRepr_RWAssemblyComponentUsage.cxx
RWStepRepr_RWAssemblyComponentUsage.hxx
RWStepRepr_RWAssemblyComponentUsageSubstitute.cxx
RWStepRepr_RWAssemblyComponentUsageSubstitute.hxx
+RWStepRepr_RWBetweenShapeAspect.cxx
+RWStepRepr_RWBetweenShapeAspect.hxx
+RWStepRepr_RWCentreOfSymmetry.cxx
+RWStepRepr_RWCentreOfSymmetry.hxx
+RWStepRepr_RWCompGroupShAspAndCompShAspAndDatumFeatAndShAsp.cxx
+RWStepRepr_RWCompGroupShAspAndCompShAspAndDatumFeatAndShAsp.hxx
+RWStepRepr_RWCompositeGroupShapeAspect.cxx
+RWStepRepr_RWCompositeGroupShapeAspect.hxx
RWStepRepr_RWCompositeShapeAspect.cxx
RWStepRepr_RWCompositeShapeAspect.hxx
RWStepRepr_RWCompoundRepresentationItem.cxx
RWStepRepr_RWCompoundRepresentationItem.hxx
+RWStepRepr_RWCompShAspAndDatumFeatAndShAsp.cxx
+RWStepRepr_RWCompShAspAndDatumFeatAndShAsp.hxx
RWStepRepr_RWConfigurationDesign.cxx
RWStepRepr_RWConfigurationDesign.hxx
RWStepRepr_RWConfigurationEffectivity.cxx
RWStepRepr_RWConfigurationEffectivity.hxx
RWStepRepr_RWConfigurationItem.cxx
RWStepRepr_RWConfigurationItem.hxx
+RWStepRepr_RWContinuosShapeAspect.cxx
+RWStepRepr_RWContinuosShapeAspect.hxx
RWStepRepr_RWDataEnvironment.cxx
RWStepRepr_RWDataEnvironment.hxx
RWStepRepr_RWDefinitionalRepresentation.cxx
RWStepRepr_RWExtension.hxx
RWStepRepr_RWFunctionallyDefinedTransformation.cxx
RWStepRepr_RWFunctionallyDefinedTransformation.hxx
+RWStepRepr_RWGeometricAlignment.cxx
+RWStepRepr_RWGeometricAlignment.hxx
RWStepRepr_RWGlobalUncertaintyAssignedContext.cxx
RWStepRepr_RWGlobalUncertaintyAssignedContext.hxx
RWStepRepr_RWGlobalUnitAssignedContext.cxx
RWStepRepr_RWGlobalUnitAssignedContext.hxx
+RWStepRepr_RWIntegerRepresentationItem.cxx
+RWStepRepr_RWIntegerRepresentationItem.hxx
RWStepRepr_RWItemDefinedTransformation.cxx
RWStepRepr_RWItemDefinedTransformation.hxx
RWStepRepr_RWMakeFromUsageOption.cxx
RWStepRepr_RWMaterialPropertyRepresentation.hxx
RWStepRepr_RWMeasureRepresentationItem.cxx
RWStepRepr_RWMeasureRepresentationItem.hxx
+RWStepRepr_RWParallelOffset.cxx
+RWStepRepr_RWParallelOffset.hxx
RWStepRepr_RWParametricRepresentationContext.cxx
RWStepRepr_RWParametricRepresentationContext.hxx
+RWStepRepr_RWPerpendicularTo.cxx
+RWStepRepr_RWPerpendicularTo.hxx
RWStepRepr_RWProductConcept.cxx
RWStepRepr_RWProductConcept.hxx
RWStepRepr_RWProductDefinitionShape.cxx
RWStepRepr_RWRepresentationRelationshipWithTransformation.hxx
RWStepRepr_RWReprItemAndLengthMeasureWithUnit.cxx
RWStepRepr_RWReprItemAndLengthMeasureWithUnit.hxx
+RWStepRepr_RWReprItemAndLengthMeasureWithUnitAndQRI.cxx
+RWStepRepr_RWReprItemAndLengthMeasureWithUnitAndQRI.hxx
+RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnit.cxx
+RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnit.hxx
+RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnitAndQRI.cxx
+RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnitAndQRI.hxx
RWStepRepr_RWShapeAspect.cxx
RWStepRepr_RWShapeAspect.hxx
RWStepRepr_RWShapeAspectDerivingRelationship.cxx
RWStepRepr_RWStructuralResponseProperty.hxx
RWStepRepr_RWStructuralResponsePropertyDefinitionRepresentation.cxx
RWStepRepr_RWStructuralResponsePropertyDefinitionRepresentation.hxx
+RWStepRepr_RWTangent.cxx
+RWStepRepr_RWTangent.hxx
+RWStepRepr_RWValueRepresentationItem.cxx
+RWStepRepr_RWValueRepresentationItem.hxx
\ No newline at end of file
--- /dev/null
+// Created on: 2015-06-29
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepRepr_RWAllAroundShapeAspect.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepRepr_AllAroundShapeAspect.hxx>
+#include <StepRepr_ProductDefinitionShape.hxx>
+
+//=======================================================================
+//function : RWStepRepr_RWCompositeShapeAspect
+//purpose :
+//=======================================================================
+
+RWStepRepr_RWAllAroundShapeAspect::RWStepRepr_RWAllAroundShapeAspect ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWAllAroundShapeAspect::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepRepr_AllAroundShapeAspect) &ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,4,ach,"all_around_shape_aspect") ) return;
+
+ // Inherited fields of ShapeAspect
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Name;
+ data->ReadString (num, 1, "shape_aspect.name", ach, aShapeAspect_Name);
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Description;
+ if ( data->IsParamDefined (num,2) ) {
+ data->ReadString (num, 2, "shape_aspect.description", ach, aShapeAspect_Description);
+ }
+
+ Handle(StepRepr_ProductDefinitionShape) aShapeAspect_OfShape;
+ data->ReadEntity (num, 3, "shape_aspect.of_shape", ach, STANDARD_TYPE(StepRepr_ProductDefinitionShape), aShapeAspect_OfShape);
+
+ StepData_Logical aShapeAspect_ProductDefinitional;
+ data->ReadLogical (num, 4, "shape_aspect.product_definitional", ach, aShapeAspect_ProductDefinitional);
+
+ // Initialize entity
+ ent->Init(aShapeAspect_Name,
+ aShapeAspect_Description,
+ aShapeAspect_OfShape,
+ aShapeAspect_ProductDefinitional);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWAllAroundShapeAspect::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepRepr_AllAroundShapeAspect) &ent) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ SW.Send (ent->Name());
+
+ SW.Send (ent->Description());
+
+ SW.Send (ent->OfShape());
+
+ SW.SendLogical (ent->ProductDefinitional());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWAllAroundShapeAspect::Share (const Handle(StepRepr_AllAroundShapeAspect) &ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ iter.AddItem (ent->OfShape());
+}
--- /dev/null
+// Created on: 2015-06-29
+// Created by: Irina KRYLOVA
+// 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 _RWStepRepr_RWAllAroundShapeAspect_HeaderFile
+#define _RWStepRepr_RWAllAroundShapeAspect_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepRepr_AllAroundShapeAspect;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write tool for AllAroundShapeAspect
+class RWStepRepr_RWAllAroundShapeAspect
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ //! Empty constructor
+ Standard_EXPORT RWStepRepr_RWAllAroundShapeAspect();
+
+ //! Reads AllAroundShapeAspect
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepRepr_AllAroundShapeAspect)& ent) const;
+
+ //! Writes AllAroundShapeAspect
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepRepr_AllAroundShapeAspect)& ent) const;
+
+ //! Fills data for graph (shared items)
+ Standard_EXPORT void Share (const Handle(StepRepr_AllAroundShapeAspect)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepRepr_RWAllAroundShapeAspect_HeaderFile
--- /dev/null
+// Created on: 2015-06-22
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepRepr_RWApex.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepRepr_Apex.hxx>
+#include <StepRepr_ProductDefinitionShape.hxx>
+
+//=======================================================================
+//function : RWStepRepr_RWApex
+//purpose :
+//=======================================================================
+
+RWStepRepr_RWApex::RWStepRepr_RWApex ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWApex::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepRepr_Apex) &ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,4,ach,"apex") ) return;
+
+ // Inherited fields of ShapeAspect
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Name;
+ data->ReadString (num, 1, "shape_aspect.name", ach, aShapeAspect_Name);
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Description;
+ if ( data->IsParamDefined (num,2) ) {
+ data->ReadString (num, 2, "shape_aspect.description", ach, aShapeAspect_Description);
+ }
+
+ Handle(StepRepr_ProductDefinitionShape) aShapeAspect_OfShape;
+ data->ReadEntity (num, 3, "shape_aspect.of_shape", ach, STANDARD_TYPE(StepRepr_ProductDefinitionShape), aShapeAspect_OfShape);
+
+ StepData_Logical aShapeAspect_ProductDefinitional;
+ data->ReadLogical (num, 4, "shape_aspect.product_definitional", ach, aShapeAspect_ProductDefinitional);
+
+ // Initialize entity
+ ent->Init(aShapeAspect_Name,
+ aShapeAspect_Description,
+ aShapeAspect_OfShape,
+ aShapeAspect_ProductDefinitional);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWApex::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepRepr_Apex) &ent) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ SW.Send (ent->Name());
+
+ SW.Send (ent->Description());
+
+ SW.Send (ent->OfShape());
+
+ SW.SendLogical (ent->ProductDefinitional());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWApex::Share (const Handle(StepRepr_Apex) &ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ iter.AddItem (ent->OfShape());
+}
--- /dev/null
+// Created on: 2015-06-22
+// Created by: Irina KRYLOVA
+// 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 _RWStepRepr_RWApex_HeaderFile
+#define _RWStepRepr_RWApex_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepRepr_Apex;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write tool for Apex
+class RWStepRepr_RWApex
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ //! Empty constructor
+ Standard_EXPORT RWStepRepr_RWApex();
+
+ //! Reads Apex
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepRepr_Apex)& ent) const;
+
+ //! Writes Apex
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepRepr_Apex)& ent) const;
+
+ //! Fills data for graph (shared items)
+ Standard_EXPORT void Share (const Handle(StepRepr_Apex)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepRepr_RWApex_HeaderFile
--- /dev/null
+// Created on: 2015-06-29
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepRepr_RWBetweenShapeAspect.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepRepr_BetweenShapeAspect.hxx>
+#include <StepRepr_ProductDefinitionShape.hxx>
+
+//=======================================================================
+//function : RWStepRepr_RWCompositeShapeAspect
+//purpose :
+//=======================================================================
+
+RWStepRepr_RWBetweenShapeAspect::RWStepRepr_RWBetweenShapeAspect ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWBetweenShapeAspect::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepRepr_BetweenShapeAspect) &ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,4,ach,"between_shape_aspect") ) return;
+
+ // Inherited fields of ShapeAspect
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Name;
+ data->ReadString (num, 1, "shape_aspect.name", ach, aShapeAspect_Name);
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Description;
+ if ( data->IsParamDefined (num,2) ) {
+ data->ReadString (num, 2, "shape_aspect.description", ach, aShapeAspect_Description);
+ }
+
+ Handle(StepRepr_ProductDefinitionShape) aShapeAspect_OfShape;
+ data->ReadEntity (num, 3, "shape_aspect.of_shape", ach, STANDARD_TYPE(StepRepr_ProductDefinitionShape), aShapeAspect_OfShape);
+
+ StepData_Logical aShapeAspect_ProductDefinitional;
+ data->ReadLogical (num, 4, "shape_aspect.product_definitional", ach, aShapeAspect_ProductDefinitional);
+
+ // Initialize entity
+ ent->Init(aShapeAspect_Name,
+ aShapeAspect_Description,
+ aShapeAspect_OfShape,
+ aShapeAspect_ProductDefinitional);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWBetweenShapeAspect::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepRepr_BetweenShapeAspect) &ent) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ SW.Send (ent->Name());
+
+ SW.Send (ent->Description());
+
+ SW.Send (ent->OfShape());
+
+ SW.SendLogical (ent->ProductDefinitional());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWBetweenShapeAspect::Share (const Handle(StepRepr_BetweenShapeAspect) &ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ iter.AddItem (ent->OfShape());
+}
--- /dev/null
+// Created on: 2015-06-29
+// Created by: Irina KRYLOVA
+// 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 _RWStepRepr_RWBetweenShapeAspect_HeaderFile
+#define _RWStepRepr_RWBetweenShapeAspect_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepRepr_BetweenShapeAspect;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write tool for BetweenShapeAspect
+class RWStepRepr_RWBetweenShapeAspect
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ //! Empty constructor
+ Standard_EXPORT RWStepRepr_RWBetweenShapeAspect();
+
+ //! Reads BetweenShapeAspect
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepRepr_BetweenShapeAspect)& ent) const;
+
+ //! Writes BetweenShapeAspect
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepRepr_BetweenShapeAspect)& ent) const;
+
+ //! Fills data for graph (shared items)
+ Standard_EXPORT void Share (const Handle(StepRepr_BetweenShapeAspect)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepRepr_RWBetweenShapeAspect_HeaderFile
--- /dev/null
+// Created on: 2015-06-22
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepRepr_RWCentreOfSymmetry.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepRepr_CentreOfSymmetry.hxx>
+#include <StepRepr_ProductDefinitionShape.hxx>
+
+//=======================================================================
+//function : RWStepRepr_RWCentreOfSymmetry
+//purpose :
+//=======================================================================
+
+RWStepRepr_RWCentreOfSymmetry::RWStepRepr_RWCentreOfSymmetry ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWCentreOfSymmetry::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepRepr_CentreOfSymmetry) &ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,4,ach,"centre_of_symmetry") ) return;
+
+ // Inherited fields of ShapeAspect
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Name;
+ data->ReadString (num, 1, "shape_aspect.name", ach, aShapeAspect_Name);
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Description;
+ if ( data->IsParamDefined (num,2) ) {
+ data->ReadString (num, 2, "shape_aspect.description", ach, aShapeAspect_Description);
+ }
+
+ Handle(StepRepr_ProductDefinitionShape) aShapeAspect_OfShape;
+ data->ReadEntity (num, 3, "shape_aspect.of_shape", ach, STANDARD_TYPE(StepRepr_ProductDefinitionShape), aShapeAspect_OfShape);
+
+ StepData_Logical aShapeAspect_ProductDefinitional;
+ data->ReadLogical (num, 4, "shape_aspect.product_definitional", ach, aShapeAspect_ProductDefinitional);
+
+ // Initialize entity
+ ent->Init(aShapeAspect_Name,
+ aShapeAspect_Description,
+ aShapeAspect_OfShape,
+ aShapeAspect_ProductDefinitional);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWCentreOfSymmetry::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepRepr_CentreOfSymmetry) &ent) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ SW.Send (ent->Name());
+
+ SW.Send (ent->Description());
+
+ SW.Send (ent->OfShape());
+
+ SW.SendLogical (ent->ProductDefinitional());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWCentreOfSymmetry::Share (const Handle(StepRepr_CentreOfSymmetry) &ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ iter.AddItem (ent->OfShape());
+}
--- /dev/null
+// Created on: 2015-06-22
+// Created by: Irina KRYLOVA
+// 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 _RWStepRepr_RWCentreOfSymmetry_HeaderFile
+#define _RWStepRepr_RWCentreOfSymmetry_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepRepr_CentreOfSymmetry;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write tool for CentreOfSymmetry
+class RWStepRepr_RWCentreOfSymmetry
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ //! Empty constructor
+ Standard_EXPORT RWStepRepr_RWCentreOfSymmetry();
+
+ //! Reads CentreOfSymmetry
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepRepr_CentreOfSymmetry)& ent) const;
+
+ //! Writes CentreOfSymmetry
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepRepr_CentreOfSymmetry)& ent) const;
+
+ //! Fills data for graph (shared items)
+ Standard_EXPORT void Share (const Handle(StepRepr_CentreOfSymmetry)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepRepr_RWCentreOfSymmetry_HeaderFile
--- /dev/null
+// Created on: 2015-08-11
+// Created by: Irina KRYLOVA
+// 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.
+
+
+#include <Interface_Check.hxx>
+#include <Interface_EntityIterator.hxx>
+#include <RWStepRepr_RWCompGroupShAspAndCompShAspAndDatumFeatAndShAsp.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp.hxx>
+#include <StepRepr_ProductDefinitionShape.hxx>
+
+//=======================================================================
+//function : RWStepRepr_RWCompGroupShAspAndCompShAspAndDatumFeatAndShAsp
+//purpose :
+//=======================================================================
+RWStepRepr_RWCompGroupShAspAndCompShAspAndDatumFeatAndShAsp::RWStepRepr_RWCompGroupShAspAndCompShAspAndDatumFeatAndShAsp()
+{
+}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWCompGroupShAspAndCompShAspAndDatumFeatAndShAsp::ReadStep
+ (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num0, Handle(Interface_Check)& ach,
+ const Handle(StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp)& ent) const
+{
+ Standard_Integer num = 0;
+ data->NamedForComplex("SHAPE_ASPECT", num0, num, ach);
+ if (!data->CheckNbParams(num, 4, ach, "shape_aspect")) return;
+
+ Handle(TCollection_HAsciiString) aName;
+ data->ReadString (num, 1, "name", ach, aName);
+
+ Handle(TCollection_HAsciiString) aDescription;
+ if (data->IsParamDefined (num, 2)) {
+ data->ReadString (num, 2, "description", ach, aDescription);
+ }
+ Handle(StepRepr_ProductDefinitionShape) aOfShape;
+ data->ReadEntity(num, 3,"of_shape", ach, STANDARD_TYPE(StepRepr_ProductDefinitionShape), aOfShape);
+
+ StepData_Logical aProductDefinitional;
+ data->ReadLogical (num,4,"product_definitional",ach,aProductDefinitional);
+
+ // Initialize the entity
+ ent->Init(aName, aDescription, aOfShape, aProductDefinitional);
+}
+
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWCompGroupShAspAndCompShAspAndDatumFeatAndShAsp::WriteStep
+ (StepData_StepWriter& SW,
+ const Handle(StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp)& ent) const
+{
+ SW.StartEntity("COMPOSITE_GROUP_SHAPE_ASPECT");
+ SW.StartEntity("COMPOSITE_SHAPE_ASPECT");
+ SW.StartEntity("DATUM_FEATURE");
+ SW.StartEntity("SHAPE_ASPECT");
+ SW.Send(ent->Name());
+ SW.Send(ent->Description());
+ SW.Send(ent->OfShape());
+ SW.SendLogical(ent->ProductDefinitional());
+}
+
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWCompGroupShAspAndCompShAspAndDatumFeatAndShAsp::Share
+ (const Handle(StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp)& ent,
+ Interface_EntityIterator& iter) const
+{
+ iter.GetOneItem(ent->OfShape());
+}
--- /dev/null
+// Created on: 2015-08-11
+// Created by: Irina KRYLOVA
+// 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 _RWStepRepr_RWCompGroupShAspAndCompShAspAndDatumFeatAndShAsp_HeaderFile
+#define _RWStepRepr_RWCompGroupShAspAndCompShAspAndDatumFeatAndShAsp_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+class StepData_StepReaderData;
+class Interface_Check;
+class StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write Module for CompGroupShAspAndCompShAspAndDatumFeatAndShAsp
+class RWStepRepr_RWCompGroupShAspAndCompShAspAndDatumFeatAndShAsp
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ Standard_EXPORT RWStepRepr_RWCompGroupShAspAndCompShAspAndDatumFeatAndShAsp();
+
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp)& ent) const;
+
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp)& ent) const;
+
+ Standard_EXPORT void Share (const Handle(StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepRepr_RWCompGroupShAspAndCompShAspAndDatumFeatAndShAsp_HeaderFile
--- /dev/null
+// Created on: 2015-08-11
+// Created by: Irina KRYLOVA
+// 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.
+
+
+#include <Interface_Check.hxx>
+#include <Interface_EntityIterator.hxx>
+#include <RWStepRepr_RWCompShAspAndDatumFeatAndShAsp.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepRepr_CompShAspAndDatumFeatAndShAsp.hxx>
+#include <StepRepr_ProductDefinitionShape.hxx>
+
+//=======================================================================
+//function : RWStepRepr_RWCompShAspAndDatumFeatAndShAsp
+//purpose :
+//=======================================================================
+RWStepRepr_RWCompShAspAndDatumFeatAndShAsp::RWStepRepr_RWCompShAspAndDatumFeatAndShAsp()
+{
+}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWCompShAspAndDatumFeatAndShAsp::ReadStep
+ (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num0, Handle(Interface_Check)& ach,
+ const Handle(StepRepr_CompShAspAndDatumFeatAndShAsp)& ent) const
+{
+ Standard_Integer num = 0;
+ data->NamedForComplex("SHAPE_ASPECT", num0, num, ach);
+ if (!data->CheckNbParams(num, 4, ach, "shape_aspect")) return;
+
+ Handle(TCollection_HAsciiString) aName;
+ data->ReadString (num, 1, "name", ach, aName);
+
+ Handle(TCollection_HAsciiString) aDescription;
+ if (data->IsParamDefined (num, 2)) {
+ data->ReadString (num, 2, "description", ach, aDescription);
+ }
+ Handle(StepRepr_ProductDefinitionShape) aOfShape;
+ data->ReadEntity(num, 3,"of_shape", ach, STANDARD_TYPE(StepRepr_ProductDefinitionShape), aOfShape);
+
+ StepData_Logical aProductDefinitional;
+ data->ReadLogical (num,4,"product_definitional",ach,aProductDefinitional);
+
+ // Initialize the entity
+ ent->Init(aName, aDescription, aOfShape, aProductDefinitional);
+}
+
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWCompShAspAndDatumFeatAndShAsp::WriteStep
+ (StepData_StepWriter& SW,
+ const Handle(StepRepr_CompShAspAndDatumFeatAndShAsp)& ent) const
+{
+ SW.StartEntity("COMPOSITE_SHAPE_ASPECT");
+ SW.StartEntity("DATUM_FEATURE");
+ SW.StartEntity("SHAPE_ASPECT");
+ SW.Send(ent->Name());
+ SW.Send(ent->Description());
+ SW.Send(ent->OfShape());
+ SW.SendLogical(ent->ProductDefinitional());
+}
+
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWCompShAspAndDatumFeatAndShAsp::Share
+ (const Handle(StepRepr_CompShAspAndDatumFeatAndShAsp)& ent,
+ Interface_EntityIterator& iter) const
+{
+ iter.GetOneItem(ent->OfShape());
+}
--- /dev/null
+// Created on: 2015-08-11
+// Created by: Irina KRYLOVA
+// 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 _RWStepRepr_RWCompShAspAndDatumFeatAndShAsp_HeaderFile
+#define _RWStepRepr_RWCompShAspAndDatumFeatAndShAsp_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+class StepData_StepReaderData;
+class Interface_Check;
+class StepRepr_CompShAspAndDatumFeatAndShAsp;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write Module for CompShAspAndDatumFeatAndShAsp
+class RWStepRepr_RWCompShAspAndDatumFeatAndShAsp
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ Standard_EXPORT RWStepRepr_RWCompShAspAndDatumFeatAndShAsp();
+
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepRepr_CompShAspAndDatumFeatAndShAsp)& ent) const;
+
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepRepr_CompShAspAndDatumFeatAndShAsp)& ent) const;
+
+ Standard_EXPORT void Share (const Handle(StepRepr_CompShAspAndDatumFeatAndShAsp)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepRepr_RWCompShAspAndDatumFeatAndShAsp_HeaderFile
--- /dev/null
+// Created on: 2015-06-29
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepRepr_RWCompositeGroupShapeAspect.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepRepr_CompositeGroupShapeAspect.hxx>
+#include <StepRepr_ProductDefinitionShape.hxx>
+
+//=======================================================================
+//function : RWStepRepr_RWCompositeShapeAspect
+//purpose :
+//=======================================================================
+
+RWStepRepr_RWCompositeGroupShapeAspect::RWStepRepr_RWCompositeGroupShapeAspect ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWCompositeGroupShapeAspect::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepRepr_CompositeGroupShapeAspect) &ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,4,ach,"composite_group_shape_aspect") ) return;
+
+ // Inherited fields of ShapeAspect
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Name;
+ data->ReadString (num, 1, "shape_aspect.name", ach, aShapeAspect_Name);
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Description;
+ if ( data->IsParamDefined (num,2) ) {
+ data->ReadString (num, 2, "shape_aspect.description", ach, aShapeAspect_Description);
+ }
+
+ Handle(StepRepr_ProductDefinitionShape) aShapeAspect_OfShape;
+ data->ReadEntity (num, 3, "shape_aspect.of_shape", ach, STANDARD_TYPE(StepRepr_ProductDefinitionShape), aShapeAspect_OfShape);
+
+ StepData_Logical aShapeAspect_ProductDefinitional;
+ data->ReadLogical (num, 4, "shape_aspect.product_definitional", ach, aShapeAspect_ProductDefinitional);
+
+ // Initialize entity
+ ent->Init(aShapeAspect_Name,
+ aShapeAspect_Description,
+ aShapeAspect_OfShape,
+ aShapeAspect_ProductDefinitional);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWCompositeGroupShapeAspect::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepRepr_CompositeGroupShapeAspect) &ent) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ SW.Send (ent->Name());
+
+ SW.Send (ent->Description());
+
+ SW.Send (ent->OfShape());
+
+ SW.SendLogical (ent->ProductDefinitional());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWCompositeGroupShapeAspect::Share (const Handle(StepRepr_CompositeGroupShapeAspect) &ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ iter.AddItem (ent->OfShape());
+}
--- /dev/null
+// Created on: 2015-06-29
+// Created by: Irina KRYLOVA
+// 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 _RWStepRepr_RWCompositeGroupShapeAspect_HeaderFile
+#define _RWStepRepr_RWCompositeGroupShapeAspect_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepRepr_CompositeGroupShapeAspect;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write tool for CompositeGroupShapeAspect
+class RWStepRepr_RWCompositeGroupShapeAspect
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ //! Empty constructor
+ Standard_EXPORT RWStepRepr_RWCompositeGroupShapeAspect();
+
+ //! Reads CompositeGroupShapeAspect
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepRepr_CompositeGroupShapeAspect)& ent) const;
+
+ //! Writes CompositeGroupShapeAspect
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepRepr_CompositeGroupShapeAspect)& ent) const;
+
+ //! Fills data for graph (shared items)
+ Standard_EXPORT void Share (const Handle(StepRepr_CompositeGroupShapeAspect)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepRepr_RWCompositeGroupShapeAspect_HeaderFile
--- /dev/null
+// Created on: 2015-06-29
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepRepr_RWContinuosShapeAspect.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepRepr_ContinuosShapeAspect.hxx>
+#include <StepRepr_ProductDefinitionShape.hxx>
+
+//=======================================================================
+//function : RWStepRepr_RWCompositeShapeAspect
+//purpose :
+//=======================================================================
+
+RWStepRepr_RWContinuosShapeAspect::RWStepRepr_RWContinuosShapeAspect ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWContinuosShapeAspect::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepRepr_ContinuosShapeAspect) &ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,4,ach,"continuos_shape_aspect") ) return;
+
+ // Inherited fields of ShapeAspect
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Name;
+ data->ReadString (num, 1, "shape_aspect.name", ach, aShapeAspect_Name);
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Description;
+ if ( data->IsParamDefined (num,2) ) {
+ data->ReadString (num, 2, "shape_aspect.description", ach, aShapeAspect_Description);
+ }
+
+ Handle(StepRepr_ProductDefinitionShape) aShapeAspect_OfShape;
+ data->ReadEntity (num, 3, "shape_aspect.of_shape", ach, STANDARD_TYPE(StepRepr_ProductDefinitionShape), aShapeAspect_OfShape);
+
+ StepData_Logical aShapeAspect_ProductDefinitional;
+ data->ReadLogical (num, 4, "shape_aspect.product_definitional", ach, aShapeAspect_ProductDefinitional);
+
+ // Initialize entity
+ ent->Init(aShapeAspect_Name,
+ aShapeAspect_Description,
+ aShapeAspect_OfShape,
+ aShapeAspect_ProductDefinitional);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWContinuosShapeAspect::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepRepr_ContinuosShapeAspect) &ent) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ SW.Send (ent->Name());
+
+ SW.Send (ent->Description());
+
+ SW.Send (ent->OfShape());
+
+ SW.SendLogical (ent->ProductDefinitional());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWContinuosShapeAspect::Share (const Handle(StepRepr_ContinuosShapeAspect) &ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ iter.AddItem (ent->OfShape());
+}
--- /dev/null
+// Created on: 2015-06-29
+// Created by: Irina KRYLOVA
+// 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 _RWStepRepr_RWContinuosShapeAspect_HeaderFile
+#define _RWStepRepr_RWContinuosShapeAspect_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepRepr_ContinuosShapeAspect;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write tool for ContinuosShapeAspect
+class RWStepRepr_RWContinuosShapeAspect
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ //! Empty constructor
+ Standard_EXPORT RWStepRepr_RWContinuosShapeAspect();
+
+ //! Reads ContinuosShapeAspect
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepRepr_ContinuosShapeAspect)& ent) const;
+
+ //! Writes ContinuosShapeAspect
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepRepr_ContinuosShapeAspect)& ent) const;
+
+ //! Fills data for graph (shared items)
+ Standard_EXPORT void Share (const Handle(StepRepr_ContinuosShapeAspect)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepRepr_RWContinuosShapeAspect_HeaderFile
--- /dev/null
+// Created on: 2015-06-22
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepRepr_RWGeometricAlignment.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <Interface_Check.hxx>
+#include <StepData_Logical.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepRepr_GeometricAlignment.hxx>
+#include <StepRepr_ProductDefinitionShape.hxx>
+#include <StepRepr_ShapeAspect.hxx>
+
+//=======================================================================
+//function : RWStepRepr_RWGeometricAlignment
+//purpose :
+//=======================================================================
+
+RWStepRepr_RWGeometricAlignment::RWStepRepr_RWGeometricAlignment ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWGeometricAlignment::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepRepr_GeometricAlignment) &ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,4,ach,"geometric_alignment") ) return;
+
+ // Inherited fields of ShapeAspect
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Name;
+ data->ReadString (num, 1, "shape_aspect.name", ach, aShapeAspect_Name);
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Description;
+ if ( data->IsParamDefined (num,2) ) {
+ data->ReadString (num, 2, "shape_aspect.description", ach, aShapeAspect_Description);
+ }
+
+ Handle(StepRepr_ProductDefinitionShape) aShapeAspect_OfShape;
+ data->ReadEntity (num, 3, "shape_aspect.of_shape", ach, STANDARD_TYPE(StepRepr_ProductDefinitionShape), aShapeAspect_OfShape);
+
+ StepData_Logical aShapeAspect_ProductDefinitional;
+ data->ReadLogical (num, 4, "shape_aspect.product_definitional", ach, aShapeAspect_ProductDefinitional);
+
+ // Initialize entity
+ ent->Init(aShapeAspect_Name,
+ aShapeAspect_Description,
+ aShapeAspect_OfShape,
+ aShapeAspect_ProductDefinitional);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWGeometricAlignment::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepRepr_GeometricAlignment) &ent) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ SW.Send (ent->Name());
+
+ SW.Send (ent->Description());
+
+ SW.Send (ent->OfShape());
+
+ SW.SendLogical (ent->ProductDefinitional());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWGeometricAlignment::Share (const Handle(StepRepr_GeometricAlignment) &ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ iter.AddItem (ent->OfShape());
+}
--- /dev/null
+// Created on: 2015-06-22
+// Created by: Irina KRYLOVA
+// 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 _RWStepRepr_RWGeometricAlignment_HeaderFile
+#define _RWStepRepr_RWGeometricAlignment_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepRepr_GeometricAlignment;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write tool for GeometricAlignment
+class RWStepRepr_RWGeometricAlignment
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ //! Empty constructor
+ Standard_EXPORT RWStepRepr_RWGeometricAlignment();
+
+ //! Reads GeometricAlignment
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepRepr_GeometricAlignment)& ent) const;
+
+ //! Writes GeometricAlignment
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepRepr_GeometricAlignment)& ent) const;
+
+ //! Fills data for graph (shared items)
+ Standard_EXPORT void Share (const Handle(StepRepr_GeometricAlignment)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepRepr_RWGeometricAlignment_HeaderFile
--- /dev/null
+// Created on: 2015-09-03
+// Created by: Irina KRYLOVA
+// 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.
+
+
+#include <Interface_Check.hxx>
+#include <RWStepRepr_RWIntegerRepresentationItem.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepRepr_IntegerRepresentationItem.hxx>
+#include <TCollection_HAsciiString.hxx>
+
+RWStepRepr_RWIntegerRepresentationItem::RWStepRepr_RWIntegerRepresentationItem () {}
+
+void RWStepRepr_RWIntegerRepresentationItem::ReadStep
+ (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepRepr_IntegerRepresentationItem)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,2,ach,"integer_representation_item") ) return;
+
+ // --- inherited field : name ---
+ Handle(TCollection_HAsciiString) aName;
+ data->ReadString (num,1,"name",ach,aName);
+
+ // --- own field : value ---
+ Standard_Integer aValue;
+ data->ReadInteger (num,2,"value",ach,aValue);
+
+ //--- Initialisation of the read entity ---
+ ent->Init(aName, aValue);
+}
+
+
+void RWStepRepr_RWIntegerRepresentationItem::WriteStep
+ (StepData_StepWriter& SW,
+ const Handle(StepRepr_IntegerRepresentationItem)& ent) const
+{
+ SW.Send(ent->Name());
+ SW.Send(ent->Value());
+}
--- /dev/null
+// Created on: 2015-09-03
+// Created by: Irina KRYLOVA
+// 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 _RWStepRepr_RWIntegerRepresentationItem_HeaderFile
+#define _RWStepRepr_RWIntegerRepresentationItem_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+class StepData_StepReaderData;
+class Interface_Check;
+class StepRepr_IntegerRepresentationItem;
+class StepData_StepWriter;
+
+
+//! Read & Write Module for IntegerRepresentationItem
+class RWStepRepr_RWIntegerRepresentationItem
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ Standard_EXPORT RWStepRepr_RWIntegerRepresentationItem();
+
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepRepr_IntegerRepresentationItem)& ent) const;
+
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepRepr_IntegerRepresentationItem)& ent) const;
+};
+#endif // _RWStepRepr_RWIntegerRepresentationItem_HeaderFile
--- /dev/null
+// Created on: 2015-06-22
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepRepr_RWParallelOffset.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepBasic_MeasureWithUnit.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepRepr_ParallelOffset.hxx>
+#include <StepRepr_ProductDefinitionShape.hxx>
+
+//=======================================================================
+//function : RWStepRepr_RWParallelOffset
+//purpose :
+//=======================================================================
+
+RWStepRepr_RWParallelOffset::RWStepRepr_RWParallelOffset ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWParallelOffset::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepRepr_ParallelOffset) &ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,5,ach,"parallel_offset") ) return;
+
+ // Inherited fields of ShapeAspect
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Name;
+ data->ReadString (num, 1, "shape_aspect.name", ach, aShapeAspect_Name);
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Description;
+ if ( data->IsParamDefined (num,2) ) {
+ data->ReadString (num, 2, "shape_aspect.description", ach, aShapeAspect_Description);
+ }
+
+ Handle(StepRepr_ProductDefinitionShape) aShapeAspect_OfShape;
+ data->ReadEntity (num, 3, "shape_aspect.of_shape", ach, STANDARD_TYPE(StepRepr_ProductDefinitionShape), aShapeAspect_OfShape);
+
+ StepData_Logical aShapeAspect_ProductDefinitional;
+ data->ReadLogical (num, 4, "shape_aspect.product_definitional", ach, aShapeAspect_ProductDefinitional);
+
+ // Own fields of ParallelOffset
+
+ Handle(StepBasic_MeasureWithUnit) anOffset;
+ data->ReadEntity (num, 5, "offset", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), anOffset);
+
+ // Initialize entity
+ ent->Init(aShapeAspect_Name,
+ aShapeAspect_Description,
+ aShapeAspect_OfShape,
+ aShapeAspect_ProductDefinitional,
+ anOffset);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWParallelOffset::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepRepr_ParallelOffset) &ent) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ SW.Send (ent->Name());
+
+ SW.Send (ent->Description());
+
+ SW.Send (ent->OfShape());
+
+ SW.SendLogical (ent->ProductDefinitional());
+
+ SW.Send(ent->Offset());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWParallelOffset::Share (const Handle(StepRepr_ParallelOffset) &ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ iter.AddItem (ent->OfShape());
+}
--- /dev/null
+// Created on: 2015-06-22
+// Created by: Irina KRYLOVA
+// 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 _RWStepRepr_RWParallelOffset_HeaderFile
+#define _RWStepRepr_RWParallelOffset_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepRepr_ParallelOffset;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write tool for ParallelOffset
+class RWStepRepr_RWParallelOffset
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ //! Empty constructor
+ Standard_EXPORT RWStepRepr_RWParallelOffset();
+
+ //! Reads ParallelOffset
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepRepr_ParallelOffset)& ent) const;
+
+ //! Writes ParallelOffset
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepRepr_ParallelOffset)& ent) const;
+
+ //! Fills data for graph (shared items)
+ Standard_EXPORT void Share (const Handle(StepRepr_ParallelOffset)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepRepr_RWParallelOffset_HeaderFile
--- /dev/null
+// Created on: 2015-06-22
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepRepr_RWPerpendicularTo.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepRepr_PerpendicularTo.hxx>
+#include <StepRepr_ProductDefinitionShape.hxx>
+
+//=======================================================================
+//function : RWStepRepr_RWPerpendicularTo
+//purpose :
+//=======================================================================
+
+RWStepRepr_RWPerpendicularTo::RWStepRepr_RWPerpendicularTo ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWPerpendicularTo::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepRepr_PerpendicularTo) &ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,4,ach,"perpendicular_to") ) return;
+
+ // Inherited fields of ShapeAspect
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Name;
+ data->ReadString (num, 1, "shape_aspect.name", ach, aShapeAspect_Name);
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Description;
+ if ( data->IsParamDefined (num,2) ) {
+ data->ReadString (num, 2, "shape_aspect.description", ach, aShapeAspect_Description);
+ }
+
+ Handle(StepRepr_ProductDefinitionShape) aShapeAspect_OfShape;
+ data->ReadEntity (num, 3, "shape_aspect.of_shape", ach, STANDARD_TYPE(StepRepr_ProductDefinitionShape), aShapeAspect_OfShape);
+
+ StepData_Logical aShapeAspect_ProductDefinitional;
+ data->ReadLogical (num, 4, "shape_aspect.product_definitional", ach, aShapeAspect_ProductDefinitional);
+
+ // Initialize entity
+ ent->Init(aShapeAspect_Name,
+ aShapeAspect_Description,
+ aShapeAspect_OfShape,
+ aShapeAspect_ProductDefinitional);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWPerpendicularTo::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepRepr_PerpendicularTo) &ent) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ SW.Send (ent->Name());
+
+ SW.Send (ent->Description());
+
+ SW.Send (ent->OfShape());
+
+ SW.SendLogical (ent->ProductDefinitional());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWPerpendicularTo::Share (const Handle(StepRepr_PerpendicularTo) &ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ iter.AddItem (ent->OfShape());
+}
--- /dev/null
+// Created on: 2015-06-22
+// Created by: Irina KRYLOVA
+// 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 _RWStepRepr_RWPerpendicularTo_HeaderFile
+#define _RWStepRepr_RWPerpendicularTo_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepRepr_PerpendicularTo;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write tool for PerpendicularTo
+class RWStepRepr_RWPerpendicularTo
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ //! Empty constructor
+ Standard_EXPORT RWStepRepr_RWPerpendicularTo();
+
+ //! Reads PerpendicularTo
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepRepr_PerpendicularTo)& ent) const;
+
+ //! Writes PerpendicularTo
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepRepr_PerpendicularTo)& ent) const;
+
+ //! Fills data for graph (shared items)
+ Standard_EXPORT void Share (const Handle(StepRepr_PerpendicularTo)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepRepr_RWPerpendicularTo_HeaderFile
--- /dev/null
+// Created on: 2015-07-22
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <Interface_Check.hxx>
+#include <RWStepRepr_RWReprItemAndLengthMeasureWithUnitAndQRI.hxx>
+#include <StepBasic_MeasureValueMember.hxx>
+#include <StepBasic_MeasureWithUnit.hxx>
+#include <StepBasic_Unit.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI.hxx>
+#include <StepShape_HArray1OfValueQualifier.hxx>
+#include <StepShape_QualifiedRepresentationItem.hxx>
+#include <StepShape_ValueQualifier.hxx>
+
+//=======================================================================
+//function : RWSteprepr_RWReprItemAndLengthMeasureWithUnitAndQRI
+//purpose :
+//=======================================================================
+RWStepRepr_RWReprItemAndLengthMeasureWithUnitAndQRI::RWStepRepr_RWReprItemAndLengthMeasureWithUnitAndQRI() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWReprItemAndLengthMeasureWithUnitAndQRI::ReadStep
+ (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num0,
+ Handle(Interface_Check)& ach,
+ const Handle(StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI)& ent) const
+{
+ Standard_Integer num = 0;//num0;
+ data->NamedForComplex("MEASURE_WITH_UNIT",num0,num,ach);
+ if (!data->CheckNbParams(num,2,ach,"measure_with_unit")) return;
+ // --- own field : valueComponent ---
+ Handle(StepBasic_MeasureValueMember) mvc = new StepBasic_MeasureValueMember;
+ data->ReadMember (num,1, "value_component", ach, mvc);
+ // --- own field : unitComponent ---
+ StepBasic_Unit aUnitComponent;
+ data->ReadEntity(num, 2,"unit_component", ach, aUnitComponent);
+ Handle(StepBasic_MeasureWithUnit) aMeasureWithUnit = new StepBasic_MeasureWithUnit;
+ aMeasureWithUnit->Init(mvc, aUnitComponent);
+
+ data->NamedForComplex("QUALIFIED_REPRESENTATION_ITEM",num0,num,ach);
+ if (!data->CheckNbParams(num,1,ach,"qualified_representation_item")) return;
+ // --- own field : qualifiers ---
+ Handle(StepShape_HArray1OfValueQualifier) quals;
+ Standard_Integer nsub;
+ if (data->ReadSubList (num, 1, "qualifiers", ach, nsub)) {
+ Standard_Integer nb = data->NbParams(nsub);
+ quals = new StepShape_HArray1OfValueQualifier (1, nb);
+ for (Standard_Integer i = 1; i <= nb; i++) {
+ StepShape_ValueQualifier aVQ;
+ if (data->ReadEntity (nsub, i, "qualifier" ,ach, aVQ))
+ quals->SetValue (i, aVQ);
+ }
+ }
+
+ Handle(StepShape_QualifiedRepresentationItem) aQRI = new StepShape_QualifiedRepresentationItem();
+ aQRI->SetQualifiers(quals);
+
+ data->NamedForComplex("REPRESENTATION_ITEM",num0,num,ach);
+ if (!data->CheckNbParams(num,1,ach,"representation_item")) return;
+ // --- own field : name ---
+ Handle(TCollection_HAsciiString) aName;
+ data->ReadString (num,1,"name",ach,aName);
+ Handle(StepRepr_RepresentationItem) aReprItem = new StepRepr_RepresentationItem;
+ aReprItem->Init(aName);
+
+ //--- Initialisation of the read entity ---
+ ent->Init(aMeasureWithUnit,aReprItem, aQRI);
+}
+
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWReprItemAndLengthMeasureWithUnitAndQRI::WriteStep
+ (StepData_StepWriter& SW,
+ const Handle(StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI)& ent) const
+{
+ SW.StartEntity("LENGTH_MEASURE_WITH_UNIT");
+ SW.StartEntity("MEASURE_REPRESENTATION_ITEM");
+ SW.StartEntity("MEASURE_WITH_UNIT");
+ SW.Send(ent->GetMeasureWithUnit()->ValueComponentMember());
+ SW.Send(ent->GetMeasureWithUnit()->UnitComponent().Value());
+ SW.StartEntity ("QUALIFIED_REPRESENTATION_ITEM");
+ Handle(StepShape_QualifiedRepresentationItem) aQRI = ent->GetQualifiedRepresentationItem();
+ Standard_Integer i, nbq = aQRI->NbQualifiers();
+ SW.OpenSub();
+ for (i = 1; i <= nbq; i ++)
+ SW.Send (aQRI->QualifiersValue(i).Value());
+ SW.CloseSub();
+ SW.StartEntity("REPRESENTATION_ITEM");
+ SW.Send(ent->Name());
+}
--- /dev/null
+// Created on: 2015-07-22
+// Created by: Irina KRYLOVA
+// 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 _RWStepRepr_RWReprItemAndLengthMeasureWithUnitAndQRI_HeaderFile
+#define _RWStepRepr_RWReprItemAndLengthMeasureWithUnitAndQRI_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+class StepData_StepReaderData;
+class Interface_Check;
+class StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI;
+class StepData_StepWriter;
+
+
+//! Read & Write Module for ReprItemAndLengthMeasureWithUnitAndQRI
+class RWStepRepr_RWReprItemAndLengthMeasureWithUnitAndQRI
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ Standard_EXPORT RWStepRepr_RWReprItemAndLengthMeasureWithUnitAndQRI();
+
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI)& ent) const;
+
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI)& ent) const;
+};
+#endif // _RWStepRepr_RWReprItemAndLengthMeasureWithUnitAndQRI_HeaderFile
--- /dev/null
+// Created on: 2015-07-22
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <Interface_Check.hxx>
+#include <RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnit.hxx>
+#include <StepBasic_MeasureValueMember.hxx>
+#include <StepBasic_MeasureWithUnit.hxx>
+#include <StepBasic_Unit.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepRepr_ReprItemAndPlaneAngleMeasureWithUnit.hxx>
+
+//=======================================================================
+//function : RWSteprepr_RWReprItemAndPlaneAngleMeasureWithUnit
+//purpose :
+//=======================================================================
+RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnit::RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnit() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnit::ReadStep
+ (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num0,
+ Handle(Interface_Check)& ach,
+ const Handle(StepRepr_ReprItemAndPlaneAngleMeasureWithUnit)& ent) const
+{
+ Standard_Integer num = 0;//num0;
+ data->NamedForComplex("MEASURE_WITH_UNIT",num0,num,ach);
+ if (!data->CheckNbParams(num,2,ach,"measure_with_unit")) return;
+ // --- own field : valueComponent ---
+ Handle(StepBasic_MeasureValueMember) mvc = new StepBasic_MeasureValueMember;
+ data->ReadMember (num,1, "value_component", ach, mvc);
+ // --- own field : unitComponent ---
+ StepBasic_Unit aUnitComponent;
+ data->ReadEntity(num, 2,"unit_component", ach, aUnitComponent);
+ Handle(StepBasic_MeasureWithUnit) aMeasureWithUnit = new StepBasic_MeasureWithUnit;
+ aMeasureWithUnit->Init(mvc, aUnitComponent);
+
+ data->NamedForComplex("REPRESENTATION_ITEM",num0,num,ach);
+ if (!data->CheckNbParams(num,1,ach,"representation_item")) return;
+ // --- own field : name ---
+ Handle(TCollection_HAsciiString) aName;
+ data->ReadString (num,1,"name",ach,aName);
+ Handle(StepRepr_RepresentationItem) aReprItem = new StepRepr_RepresentationItem;
+ aReprItem->Init(aName);
+
+ //--- Initialisation of the read entity ---
+ ent->Init(aMeasureWithUnit,aReprItem);
+}
+
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnit::WriteStep
+ (StepData_StepWriter& SW,
+ const Handle(StepRepr_ReprItemAndPlaneAngleMeasureWithUnit)& ent) const
+{
+ SW.StartEntity("MEASURE_REPRESENTATION_ITEM");
+ SW.StartEntity("MEASURE_WITH_UNIT");
+ SW.Send(ent->GetMeasureWithUnit()->ValueComponentMember());
+ SW.Send(ent->GetMeasureWithUnit()->UnitComponent().Value());
+ SW.StartEntity("PLANE_ANGLE_MEASURE_WITH_UNIT");
+ SW.StartEntity("REPRESENTATION_ITEM");
+ SW.Send(ent->Name());
+}
--- /dev/null
+// Created on: 2015-07-22
+// Created by: Irina KRYLOVA
+// 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 _RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnit_HeaderFile
+#define _RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnit_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+class StepData_StepReaderData;
+class Interface_Check;
+class StepRepr_ReprItemAndPlaneAngleMeasureWithUnit;
+class StepData_StepWriter;
+
+
+//! Read & Write Module for ReprItemAndPlaneAngleMeasureWithUni
+class RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnit
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ Standard_EXPORT RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnit();
+
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepRepr_ReprItemAndPlaneAngleMeasureWithUnit)& ent) const;
+
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepRepr_ReprItemAndPlaneAngleMeasureWithUnit)& ent) const;
+};
+#endif // _RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnit_HeaderFile
--- /dev/null
+// Created on: 2015-07-22
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <Interface_Check.hxx>
+#include <RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnitAndQRI.hxx>
+#include <StepBasic_MeasureValueMember.hxx>
+#include <StepBasic_MeasureWithUnit.hxx>
+#include <StepBasic_Unit.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI.hxx>
+#include <StepShape_HArray1OfValueQualifier.hxx>
+#include <StepShape_QualifiedRepresentationItem.hxx>
+#include <StepShape_ValueQualifier.hxx>
+
+//=======================================================================
+//function : RWSteprepr_RWReprItemAndPlaneAngleMeasureWithUnitAndQRI
+//purpose :
+//=======================================================================
+RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnitAndQRI::RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnitAndQRI() {}
+
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnitAndQRI::ReadStep
+ (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num0,
+ Handle(Interface_Check)& ach,
+ const Handle(StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI)& ent) const
+{
+ Standard_Integer num = 0;//num0;
+ data->NamedForComplex("MEASURE_WITH_UNIT",num0,num,ach);
+ if (!data->CheckNbParams(num,2,ach,"measure_with_unit")) return;
+ // --- own field : valueComponent ---
+ Handle(StepBasic_MeasureValueMember) mvc = new StepBasic_MeasureValueMember;
+ data->ReadMember (num,1, "value_component", ach, mvc);
+ // --- own field : unitComponent ---
+ StepBasic_Unit aUnitComponent;
+ data->ReadEntity(num, 2,"unit_component", ach, aUnitComponent);
+ Handle(StepBasic_MeasureWithUnit) aMeasureWithUnit = new StepBasic_MeasureWithUnit;
+ aMeasureWithUnit->Init(mvc, aUnitComponent);
+
+ data->NamedForComplex("QUALIFIED_REPRESENTATION_ITEM",num0,num,ach);
+ if (!data->CheckNbParams(num,1,ach,"qualified_representation_item")) return;
+ // --- own field : qualifiers ---
+ Handle(StepShape_HArray1OfValueQualifier) quals;
+ Standard_Integer nsub;
+ if (data->ReadSubList (num, 1, "qualifiers", ach, nsub)) {
+ Standard_Integer nb = data->NbParams(nsub);
+ quals = new StepShape_HArray1OfValueQualifier (1, nb);
+ for (Standard_Integer i = 1; i <= nb; i++) {
+ StepShape_ValueQualifier aVQ;
+ if (data->ReadEntity (nsub, i, "qualifier" ,ach, aVQ))
+ quals->SetValue (i, aVQ);
+ }
+ }
+ Handle(StepShape_QualifiedRepresentationItem) aQRI = new StepShape_QualifiedRepresentationItem();
+ aQRI->SetQualifiers(quals);
+
+ data->NamedForComplex("REPRESENTATION_ITEM",num0,num,ach);
+ if (!data->CheckNbParams(num,1,ach,"representation_item")) return;
+ // --- own field : name ---
+ Handle(TCollection_HAsciiString) aName;
+ data->ReadString (num,1,"name",ach,aName);
+ Handle(StepRepr_RepresentationItem) aReprItem = new StepRepr_RepresentationItem;
+ aReprItem->Init(aName);
+
+ //--- Initialisation of the read entity ---
+ ent->Init(aMeasureWithUnit,aReprItem, aQRI);
+}
+
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnitAndQRI::WriteStep
+ (StepData_StepWriter& SW,
+ const Handle(StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI)& ent) const
+{
+ SW.StartEntity("MEASURE_REPRESENTATION_ITEM");
+ SW.StartEntity("MEASURE_WITH_UNIT");
+ SW.Send(ent->GetMeasureWithUnit()->ValueComponentMember());
+ SW.Send(ent->GetMeasureWithUnit()->UnitComponent().Value());
+ SW.StartEntity("PLANE_ANGLE_MEASURE_WITH_UNIT");
+ SW.StartEntity ("QUALIFIED_REPRESENTATION_ITEM");
+ Handle(StepShape_QualifiedRepresentationItem) aQRI = ent->GetQualifiedRepresentationItem();
+ Standard_Integer i, nbq = aQRI->NbQualifiers();
+ SW.OpenSub();
+ for (i = 1; i <= nbq; i ++)
+ SW.Send (aQRI->QualifiersValue(i).Value());
+ SW.CloseSub();
+ SW.StartEntity("REPRESENTATION_ITEM");
+ SW.Send(ent->Name());
+}
--- /dev/null
+// Created on: 2015-07-22
+// Created by: Irina KRYLOVA
+// 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 _RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnitAndQRI_HeaderFile
+#define _RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnitAndQRI_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+class StepData_StepReaderData;
+class Interface_Check;
+class StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI;
+class StepData_StepWriter;
+
+
+//! Read & Write Module for ReprItemAndPlaneAngleMeasureWithUnitAndQRI
+class RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnitAndQRI
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ Standard_EXPORT RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnitAndQRI();
+
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI)& ent) const;
+
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI)& ent) const;
+};
+#endif // _RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnitAndQRI_HeaderFile
--- /dev/null
+// Created on: 2015-06-22
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepRepr_RWTangent.hxx>
+
+#include <Interface_EntityIterator.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepRepr_ProductDefinitionShape.hxx>
+#include <StepRepr_Tangent.hxx>
+
+//=======================================================================
+//function : RWStepRepr_RWTangent
+//purpose :
+//=======================================================================
+
+RWStepRepr_RWTangent::RWStepRepr_RWTangent ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWTangent::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepRepr_Tangent) &ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,4,ach,"tangent") ) return;
+
+ // Inherited fields of ShapeAspect
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Name;
+ data->ReadString (num, 1, "shape_aspect.name", ach, aShapeAspect_Name);
+
+ Handle(TCollection_HAsciiString) aShapeAspect_Description;
+ if ( data->IsParamDefined (num,2) ) {
+ data->ReadString (num, 2, "shape_aspect.description", ach, aShapeAspect_Description);
+ }
+
+ Handle(StepRepr_ProductDefinitionShape) aShapeAspect_OfShape;
+ data->ReadEntity (num, 3, "shape_aspect.of_shape", ach, STANDARD_TYPE(StepRepr_ProductDefinitionShape), aShapeAspect_OfShape);
+
+ StepData_Logical aShapeAspect_ProductDefinitional;
+ data->ReadLogical (num, 4, "shape_aspect.product_definitional", ach, aShapeAspect_ProductDefinitional);
+
+ // Initialize entity
+ ent->Init(aShapeAspect_Name,
+ aShapeAspect_Description,
+ aShapeAspect_OfShape,
+ aShapeAspect_ProductDefinitional);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWTangent::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepRepr_Tangent) &ent) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ SW.Send (ent->Name());
+
+ SW.Send (ent->Description());
+
+ SW.Send (ent->OfShape());
+
+ SW.SendLogical (ent->ProductDefinitional());
+}
+
+//=======================================================================
+//function : Share
+//purpose :
+//=======================================================================
+
+void RWStepRepr_RWTangent::Share (const Handle(StepRepr_Tangent) &ent,
+ Interface_EntityIterator& iter) const
+{
+
+ // Inherited fields of ShapeAspect
+
+ iter.AddItem (ent->OfShape());
+}
--- /dev/null
+// Created on: 2015-06-22
+// Created by: Irina KRYLOVA
+// 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 _RWStepRepr_RWTangent_HeaderFile
+#define _RWStepRepr_RWTangent_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepRepr_Tangent;
+class StepData_StepWriter;
+class Interface_EntityIterator;
+
+
+//! Read & Write tool for Tangent
+class RWStepRepr_RWTangent
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ //! Empty constructor
+ Standard_EXPORT RWStepRepr_RWTangent();
+
+ //! Reads Tangent
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepRepr_Tangent)& ent) const;
+
+ //! Writes Tangent
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepRepr_Tangent)& ent) const;
+
+ //! Fills data for graph (shared items)
+ Standard_EXPORT void Share (const Handle(StepRepr_Tangent)& ent, Interface_EntityIterator& iter) const;
+};
+#endif // _RWStepRepr_RWTangent_HeaderFile
--- /dev/null
+// Created on: 2015-09-09
+// Created by: Irina KRYLOVA
+// 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.
+
+
+#include <Interface_Check.hxx>
+#include <RWStepRepr_RWValueRepresentationItem.hxx>
+#include <StepBasic_MeasureValueMember.hxx>
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepRepr_ValueRepresentationItem.hxx>
+#include <TCollection_HAsciiString.hxx>
+
+RWStepRepr_RWValueRepresentationItem::RWStepRepr_RWValueRepresentationItem () {}
+
+void RWStepRepr_RWValueRepresentationItem::ReadStep
+ (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepRepr_ValueRepresentationItem)& ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,2,ach,"value_representation_item") ) return;
+
+ // --- inherited field : name ---
+ Handle(TCollection_HAsciiString) aName;
+ data->ReadString (num,1,"name",ach,aName);
+
+ // --- own field : value_component ---
+ Handle(StepBasic_MeasureValueMember) aMember = new StepBasic_MeasureValueMember;
+ data->ReadMember (num,2, "value_component", ach, aMember);
+
+ //--- Initialisation of the read entity ---
+ ent->Init(aName, aMember);
+}
+
+
+void RWStepRepr_RWValueRepresentationItem::WriteStep
+ (StepData_StepWriter& SW,
+ const Handle(StepRepr_ValueRepresentationItem)& ent) const
+{
+ SW.Send(ent->Name());
+ SW.Send(ent->ValueComponentMember());
+}
--- /dev/null
+// Created on: 2015-09-09
+// Created by: Irina KRYLOVA
+// 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 _RWStepRepr_RWValueRepresentationItem_HeaderFile
+#define _RWStepRepr_RWValueRepresentationItem_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+class StepData_StepReaderData;
+class Interface_Check;
+class StepRepr_ValueRepresentationItem;
+class StepData_StepWriter;
+
+
+//! Read & Write Module for ValueRepresentationItem
+class RWStepRepr_RWValueRepresentationItem
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ Standard_EXPORT RWStepRepr_RWValueRepresentationItem();
+
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepRepr_ValueRepresentationItem)& ent) const;
+
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepRepr_ValueRepresentationItem)& ent) const;
+};
+#endif // _RWStepRepr_RWValueRepresentationItem_HeaderFile
RWStepShape_RWTransitionalShapeRepresentation.hxx
RWStepShape_RWTypeQualifier.cxx
RWStepShape_RWTypeQualifier.hxx
+RWStepShape_RWValueFormatTypeQualifier.cxx
+RWStepShape_RWValueFormatTypeQualifier.hxx
RWStepShape_RWVertex.cxx
RWStepShape_RWVertex.hxx
RWStepShape_RWVertexLoop.cxx
#include <StepRepr_HArray1OfRepresentationItem.hxx>
#include <StepRepr_RepresentationContext.hxx>
#include <StepRepr_RepresentationItem.hxx>
+#include <StepShape_HArray1OfShapeDimensionRepresentationItem.hxx>
#include <StepShape_ShapeDimensionRepresentation.hxx>
//=======================================================================
data->ReadString (num, 1, "representation.name", ach, aRepresentation_Name);
Handle(StepRepr_HArray1OfRepresentationItem) aRepresentation_Items;
+ Handle(StepShape_HArray1OfShapeDimensionRepresentationItem) anItems;
Standard_Integer sub2 = 0;
if ( data->ReadSubList (num, 2, "representation.items", ach, sub2) ) {
Standard_Integer num2 = sub2;
Standard_Integer nb0 = data->NbParams(num2);
- aRepresentation_Items = new StepRepr_HArray1OfRepresentationItem (1, nb0);
- for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
- Handle(StepRepr_RepresentationItem) anIt0;
- data->ReadEntity (num2, i0, "representation.items", ach, STANDARD_TYPE(StepRepr_RepresentationItem), anIt0);
- aRepresentation_Items->SetValue(i0, anIt0);
+ Handle(StepRepr_RepresentationItem) anIt0;
+ StepShape_ShapeDimensionRepresentationItem anIt0AP242;
+ if (data->ReadEntity (num2, 1, "representation.items", ach, STANDARD_TYPE(StepRepr_RepresentationItem), anIt0)) {
+ aRepresentation_Items = new StepRepr_HArray1OfRepresentationItem (1, nb0);
+ for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
+ data->ReadEntity (num2, i0, "representation.items", ach, STANDARD_TYPE(StepRepr_RepresentationItem), anIt0);
+ aRepresentation_Items->SetValue(i0, anIt0);
+ }
+ }
+ else {
+ anItems = new StepShape_HArray1OfShapeDimensionRepresentationItem (1, nb0);
+ for ( Standard_Integer i0=1; i0 <= nb0; i0++ ) {
+ data->ReadEntity (num2, i0, "representation.items", ach, anIt0AP242);
+ anItems->SetValue(i0, anIt0AP242);
+ }
}
}
data->ReadEntity (num, 3, "representation.context_of_items", ach, STANDARD_TYPE(StepRepr_RepresentationContext), aRepresentation_ContextOfItems);
// Initialize entity
- ent->Init(aRepresentation_Name,
- aRepresentation_Items,
- aRepresentation_ContextOfItems);
+ if (anItems.IsNull()) {
+ ent->Init(aRepresentation_Name,
+ aRepresentation_Items,
+ aRepresentation_ContextOfItems);
+ }
+ else {
+ ent->Init(aRepresentation_Name,
+ anItems,
+ aRepresentation_ContextOfItems);
+ }
}
//=======================================================================
SW.Send (ent->StepRepr_Representation::Name());
SW.OpenSub();
- for (Standard_Integer i1=1; i1 <= ent->StepRepr_Representation::Items()->Length(); i1++ ) {
- Handle(StepRepr_RepresentationItem) Var0 = ent->StepRepr_Representation::Items()->Value(i1);
- SW.Send (Var0);
+ if (ent->ItemsAP242().IsNull()) {
+ for (Standard_Integer i1=1; i1 <= ent->StepRepr_Representation::Items()->Length(); i1++ ) {
+ Handle(StepRepr_RepresentationItem) Var0 = ent->StepRepr_Representation::Items()->Value(i1);
+ SW.Send (Var0);
+ }
+ }
+ else {
+ for (Standard_Integer i1=1; i1 <= ent->ItemsAP242()->Length(); i1++ ) {
+ StepShape_ShapeDimensionRepresentationItem Var0 = ent->ItemsAP242()->Value(i1);
+ SW.Send (Var0.Value());
+ }
}
SW.CloseSub();
// Inherited fields of Representation
- for (Standard_Integer i1=1; i1 <= ent->StepRepr_Representation::Items()->Length(); i1++ ) {
- Handle(StepRepr_RepresentationItem) Var0 = ent->StepRepr_Representation::Items()->Value(i1);
- iter.AddItem (Var0);
+ if (ent->ItemsAP242().IsNull()) {
+ for (Standard_Integer i1=1; i1 <= ent->StepRepr_Representation::Items()->Length(); i1++ ) {
+ Handle(StepRepr_RepresentationItem) Var0 = ent->StepRepr_Representation::Items()->Value(i1);
+ iter.AddItem (Var0);
+ }
+ }
+ else {
+ for (Standard_Integer i1=1; i1 <= ent->ItemsAP242()->Length(); i1++ ) {
+ StepShape_ShapeDimensionRepresentationItem Var0 = ent->ItemsAP242()->Value(i1);
+ iter.AddItem (Var0.Value());
+ }
}
iter.AddItem (ent->StepRepr_Representation::ContextOfItems());
--- /dev/null
+// Created on: 2015-07-14
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <RWStepShape_RWValueFormatTypeQualifier.hxx>
+
+#include <StepData_StepReaderData.hxx>
+#include <StepData_StepWriter.hxx>
+#include <StepShape_ValueFormatTypeQualifier.hxx>
+
+//=======================================================================
+//function : RWStepShape_RWValueFormatTypeQualifier
+//purpose :
+//=======================================================================
+
+RWStepShape_RWValueFormatTypeQualifier::RWStepShape_RWValueFormatTypeQualifier ()
+{
+}
+
+//=======================================================================
+//function : ReadStep
+//purpose :
+//=======================================================================
+
+void RWStepShape_RWValueFormatTypeQualifier::ReadStep (const Handle(StepData_StepReaderData)& data,
+ const Standard_Integer num,
+ Handle(Interface_Check)& ach,
+ const Handle(StepShape_ValueFormatTypeQualifier) &ent) const
+{
+ // Check number of parameters
+ if ( ! data->CheckNbParams(num,1,ach,"value_format_type_qualifier") ) return;
+
+ // Own fields of ValueFormatTypeQualifier
+
+ Handle(TCollection_HAsciiString) aFormatType;
+ data->ReadString (num, 1, "format_type", ach, aFormatType);
+
+ // Initialize entity
+ ent->Init(aFormatType);
+}
+
+//=======================================================================
+//function : WriteStep
+//purpose :
+//=======================================================================
+
+void RWStepShape_RWValueFormatTypeQualifier::WriteStep (StepData_StepWriter& SW,
+ const Handle(StepShape_ValueFormatTypeQualifier) &ent) const
+{
+ SW.Send (ent->FormatType());
+}
--- /dev/null
+// Created on: 2015-07-14
+// Created by: Irina KRYLOVA
+// 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 _RWStepShape_RWValueFormatTypeQualifier_HeaderFile
+#define _RWStepShape_RWValueFormatTypeQualifier_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+
+class StepData_StepReaderData;
+class Interface_Check;
+class StepShape_ValueFormatTypeQualifier;
+class StepData_StepWriter;
+
+//! Read & Write tool for ValueFormatTypeQualifier
+class RWStepShape_RWValueFormatTypeQualifier
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+
+ //! Empty constructor
+ Standard_EXPORT RWStepShape_RWValueFormatTypeQualifier();
+
+ //! Reads ValueFormatTypeQualifier
+ Standard_EXPORT void ReadStep (const Handle(StepData_StepReaderData)& data, const Standard_Integer num, Handle(Interface_Check)& ach, const Handle(StepShape_ValueFormatTypeQualifier)& ent) const;
+
+ //! Writes ValueFormatTypeQualifier
+ Standard_EXPORT void WriteStep (StepData_StepWriter& SW, const Handle(StepShape_ValueFormatTypeQualifier)& ent) const;
+
+};
+#endif // _RWStepShape_RWValueFormatTypeQualifier_HeaderFile
#include <StepDimTol_ConcentricityTolerance.hxx>
#include <StepDimTol_CircularRunoutTolerance.hxx>
#include <StepDimTol_CoaxialityTolerance.hxx>
+#include <StepDimTol_CylindricityTolerance.hxx>
#include <StepDimTol_FlatnessTolerance.hxx>
#include <StepDimTol_LineProfileTolerance.hxx>
#include <StepDimTol_ParallelismTolerance.hxx>
#include <StepFEA_SymmetricTensor42d.hxx>
#include <StepFEA_SymmetricTensor43d.hxx>
+// Added by ika for GD&T AP242
+#include <StepRepr_Apex.hxx>
+#include <StepRepr_CentreOfSymmetry.hxx>
+#include <StepRepr_GeometricAlignment.hxx>
+#include <StepRepr_ParallelOffset.hxx>
+#include <StepRepr_PerpendicularTo.hxx>
+#include <StepRepr_Tangent.hxx>
+#include <StepAP242_GeometricItemSpecificUsage.hxx>
+#include <StepAP242_IdAttribute.hxx>
+#include <StepAP242_ItemIdentifiedRepresentationUsage.hxx>
+#include <StepRepr_AllAroundShapeAspect.hxx>
+#include <StepRepr_BetweenShapeAspect.hxx>
+#include <StepRepr_CompositeGroupShapeAspect.hxx>
+#include <StepRepr_ContinuosShapeAspect.hxx>
+#include <StepDimTol_GeometricToleranceWithDefinedAreaUnit.hxx>
+#include <StepDimTol_GeometricToleranceWithDefinedUnit.hxx>
+#include <StepDimTol_GeometricToleranceWithMaximumTolerance.hxx>
+#include <StepDimTol_GeometricToleranceWithModifiers.hxx>
+#include <StepDimTol_UnequallyDisposedGeometricTolerance.hxx>
+#include <StepDimTol_NonUniformZoneDefinition.hxx>
+#include <StepDimTol_ProjectedZoneDefinition.hxx>
+#include <StepDimTol_RunoutZoneDefinition.hxx>
+#include <StepDimTol_RunoutZoneOrientation.hxx>
+#include <StepDimTol_ToleranceZone.hxx>
+#include <StepDimTol_ToleranceZoneDefinition.hxx>
+#include <StepDimTol_ToleranceZoneForm.hxx>
+#include <StepShape_ValueFormatTypeQualifier.hxx>
+#include <StepDimTol_DatumReferenceCompartment.hxx>
+#include <StepDimTol_DatumReferenceElement.hxx>
+#include <StepDimTol_DatumReferenceModifierWithValue.hxx>
+#include <StepDimTol_DatumSystem.hxx>
+#include <StepDimTol_GeneralDatumReference.hxx>
+#include <StepRepr_ReprItemAndPlaneAngleMeasureWithUnit.hxx>
+#include <StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI.hxx>
+#include <StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI.hxx>
+#include <StepDimTol_GeoTolAndGeoTolWthDatRef.hxx>
+#include <StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod.hxx>
+#include <StepDimTol_GeoTolAndGeoTolWthMod.hxx>
+#include <StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol.hxx>
+#include <StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp.hxx>
+#include <StepRepr_CompShAspAndDatumFeatAndShAsp.hxx>
+#include <StepRepr_IntegerRepresentationItem.hxx>
+#include <StepRepr_ValueRepresentationItem.hxx>
+
static int init = 0;
-static Interface_DataMapOfTransientInteger types(500);
+static Interface_DataMapOfTransientInteger types(800);
//=======================================================================
types.Bind (STANDARD_TYPE(StepBasic_DocumentProductEquivalence),601);
//TR12J 4.06.2003 G&DT entities
+ types.Bind (STANDARD_TYPE(StepDimTol_CylindricityTolerance), 609);
types.Bind (STANDARD_TYPE(StepShape_ShapeRepresentationWithParameters),610);
types.Bind (STANDARD_TYPE(StepDimTol_AngularityTolerance),611);
types.Bind (STANDARD_TYPE(StepDimTol_ConcentricityTolerance),612);
// added by skl 10.02.2004 for TRJ13
types.Bind (STANDARD_TYPE(StepBasic_ConversionBasedUnitAndMassUnit),650);
types.Bind (STANDARD_TYPE(StepBasic_MassMeasureWithUnit), 651);
+
+ // Added by ika for GD&T AP242
+ types.Bind (STANDARD_TYPE(StepRepr_Apex), 660);
+ types.Bind (STANDARD_TYPE(StepRepr_CentreOfSymmetry), 661);
+ types.Bind (STANDARD_TYPE(StepRepr_GeometricAlignment), 662);
+ types.Bind (STANDARD_TYPE(StepRepr_PerpendicularTo), 663);
+ types.Bind (STANDARD_TYPE(StepRepr_Tangent), 664);
+ types.Bind (STANDARD_TYPE(StepRepr_ParallelOffset), 665);
+ types.Bind (STANDARD_TYPE(StepAP242_GeometricItemSpecificUsage), 666);
+ types.Bind (STANDARD_TYPE(StepAP242_IdAttribute), 667);
+ types.Bind (STANDARD_TYPE(StepAP242_ItemIdentifiedRepresentationUsage), 668);
+ types.Bind (STANDARD_TYPE(StepRepr_AllAroundShapeAspect), 669);
+ types.Bind (STANDARD_TYPE(StepRepr_BetweenShapeAspect), 670);
+ types.Bind (STANDARD_TYPE(StepRepr_CompositeGroupShapeAspect), 671);
+ types.Bind (STANDARD_TYPE(StepRepr_ContinuosShapeAspect), 672);
+ types.Bind (STANDARD_TYPE(StepDimTol_GeometricToleranceWithDefinedAreaUnit), 673);
+ types.Bind (STANDARD_TYPE(StepDimTol_GeometricToleranceWithDefinedUnit), 674);
+ types.Bind (STANDARD_TYPE(StepDimTol_GeometricToleranceWithMaximumTolerance), 675);
+ types.Bind (STANDARD_TYPE(StepDimTol_GeometricToleranceWithModifiers), 676);
+ types.Bind (STANDARD_TYPE(StepDimTol_UnequallyDisposedGeometricTolerance), 677);
+ types.Bind (STANDARD_TYPE(StepDimTol_NonUniformZoneDefinition), 678);
+ types.Bind (STANDARD_TYPE(StepDimTol_ProjectedZoneDefinition), 679);
+ types.Bind (STANDARD_TYPE(StepDimTol_RunoutZoneDefinition), 680);
+ types.Bind (STANDARD_TYPE(StepDimTol_RunoutZoneOrientation), 681);
+ types.Bind (STANDARD_TYPE(StepDimTol_ToleranceZone), 682);
+ types.Bind (STANDARD_TYPE(StepDimTol_ToleranceZoneDefinition), 683);
+ types.Bind (STANDARD_TYPE(StepDimTol_ToleranceZoneForm), 684);
+ types.Bind (STANDARD_TYPE(StepShape_ValueFormatTypeQualifier), 685);
+ types.Bind (STANDARD_TYPE(StepDimTol_DatumReferenceCompartment), 686);
+ types.Bind (STANDARD_TYPE(StepDimTol_DatumReferenceElement), 687);
+ types.Bind (STANDARD_TYPE(StepDimTol_DatumReferenceModifierWithValue), 688);
+ types.Bind (STANDARD_TYPE(StepDimTol_DatumSystem), 689);
+ types.Bind (STANDARD_TYPE(StepDimTol_GeneralDatumReference), 690);
+ types.Bind (STANDARD_TYPE(StepRepr_ReprItemAndPlaneAngleMeasureWithUnit), 691);
+ types.Bind (STANDARD_TYPE(StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI), 692);
+ types.Bind (STANDARD_TYPE(StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI), 693);
+ types.Bind (STANDARD_TYPE(StepDimTol_GeoTolAndGeoTolWthDatRef), 694);
+ types.Bind (STANDARD_TYPE(StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod), 695);
+ types.Bind (STANDARD_TYPE(StepDimTol_GeoTolAndGeoTolWthMod), 696);
+ types.Bind (STANDARD_TYPE(StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol), 697);
+ types.Bind (STANDARD_TYPE(StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp), 698);
+ types.Bind (STANDARD_TYPE(StepRepr_CompShAspAndDatumFeatAndShAsp), 699);
+ types.Bind (STANDARD_TYPE(StepRepr_IntegerRepresentationItem), 700);
+ types.Bind (STANDARD_TYPE(StepRepr_ValueRepresentationItem), 701);
}
//=======================================================================
--- /dev/null
+StepAP242_GeometricItemSpecificUsage.cxx
+StepAP242_GeometricItemSpecificUsage.hxx
+StepAP242_IdAttribute.cxx
+StepAP242_IdAttribute.hxx
+StepAP242_IdAttributeSelect.cxx
+StepAP242_IdAttributeSelect.hxx
+StepAP242_ItemIdentifiedRepresentationUsage.cxx
+StepAP242_ItemIdentifiedRepresentationUsage.hxx
+StepAP242_ItemIdentifiedRepresentationUsageDefinition.cxx
+StepAP242_ItemIdentifiedRepresentationUsageDefinition.hxx
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepAP242_GeometricItemSpecificUsage.hxx>
+
+StepAP242_GeometricItemSpecificUsage::StepAP242_GeometricItemSpecificUsage () { }
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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 _StepAP242_GeometricItemSpecificUsage_HeaderFile
+#define _StepAP242_GeometricItemSpecificUsage_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepAP242_ItemIdentifiedRepresentationUsage.hxx>
+
+class StepAP242_GeometricItemSpecificUsage;
+DEFINE_STANDARD_HANDLE(StepAP242_GeometricItemSpecificUsage, StepAP242_ItemIdentifiedRepresentationUsage)
+//! Added for Dimensional Tolerances
+class StepAP242_GeometricItemSpecificUsage : public StepAP242_ItemIdentifiedRepresentationUsage
+{
+
+public:
+
+ Standard_EXPORT StepAP242_GeometricItemSpecificUsage();
+
+ DEFINE_STANDARD_RTTI(StepAP242_GeometricItemSpecificUsage, StepAP242_ItemIdentifiedRepresentationUsage)
+
+private:
+};
+#endif // _StepAP242_GeometricItemSpecificUsage_HeaderFile
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepAP242_IdAttribute.hxx>
+
+//=======================================================================
+//function : StepAP242_IdAttribute
+//purpose :
+//=======================================================================
+
+StepAP242_IdAttribute::StepAP242_IdAttribute () {}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepAP242_IdAttribute::Init(
+ const Handle(TCollection_HAsciiString)& theAttributeValue,
+ const StepAP242_IdAttributeSelect& theIdentifiedItem)
+{
+ // --- classe own fields ---
+ attributeValue = theAttributeValue;
+ identifiedItem = theIdentifiedItem;
+}
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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 _StepAP242_IdAttribute_HeaderFile
+#define _StepAP242_IdAttribute_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepAP242_IdAttributeSelect.hxx>
+#include <MMgt_TShared.hxx>
+class TCollection_HAsciiString;
+class StepAP242_IdAttributeSelect;
+
+class StepAP242_IdAttribute;
+DEFINE_STANDARD_HANDLE(StepAP242_IdAttribute, MMgt_TShared)
+class StepAP242_IdAttribute : public MMgt_TShared
+{
+
+public:
+
+ //! Returns a IdAttribute
+ Standard_EXPORT StepAP242_IdAttribute();
+
+ //! Init all field own and inherited
+ Standard_EXPORT virtual void Init (const Handle(TCollection_HAsciiString)& theAttributeValue, const StepAP242_IdAttributeSelect& theIdentifiedItem) ;
+
+ // Set field AttributeValue
+ inline void SetAttributeValue(const Handle(TCollection_HAsciiString)& theAttributeValue)
+ {
+ attributeValue = theAttributeValue;
+ }
+
+ //! Returns field AttributeValue
+ inline Handle(TCollection_HAsciiString) AttributeValue() const
+ {
+ return attributeValue;
+ }
+
+ //! Set field IdentifiedItem
+ inline void SetIdentifiedItem(const StepAP242_IdAttributeSelect& theIdentifiedItem)
+ {
+ identifiedItem = theIdentifiedItem;
+ }
+
+ //! Returns IdentifiedItem
+ inline StepAP242_IdAttributeSelect IdentifiedItem() const
+ {
+ return identifiedItem;
+ }
+
+ DEFINE_STANDARD_RTTI(StepAP242_IdAttribute, MMgt_TShared)
+
+private:
+ Handle(TCollection_HAsciiString) attributeValue;
+ StepAP242_IdAttributeSelect identifiedItem;
+};
+#endif // _StepAP242_IdAttribute_HeaderFile
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepAP242_IdAttributeSelect.hxx>
+#include <Interface_Macros.hxx>
+#include <StepBasic_Action.hxx>
+#include <StepBasic_Address.hxx>
+#include <StepBasic_ApplicationContext.hxx>
+#include <StepBasic_Group.hxx>
+#include <StepBasic_ProductCategory.hxx>
+#include <StepDimTol_GeometricTolerance.hxx>
+#include <StepRepr_PropertyDefinition.hxx>
+#include <StepRepr_Representation.hxx>
+#include <StepRepr_ShapeAspect.hxx>
+#include <StepRepr_ShapeAspectRelationship.hxx>
+#include <StepShape_DimensionalSize.hxx>
+
+//=======================================================================
+//function : StepAP242_IdAttributeSelect
+//purpose :
+//=======================================================================
+
+StepAP242_IdAttributeSelect::StepAP242_IdAttributeSelect () { }
+
+//=======================================================================
+//function : CaseNum
+//purpose :
+//=======================================================================
+
+Standard_Integer StepAP242_IdAttributeSelect::CaseNum(const Handle(Standard_Transient)& ent) const
+{
+ if (ent.IsNull()) return 0;
+ if (ent->IsKind(STANDARD_TYPE(StepBasic_Action))) return 1;
+ if (ent->IsKind(STANDARD_TYPE(StepBasic_Address))) return 2;
+ if (ent->IsKind(STANDARD_TYPE(StepBasic_ApplicationContext))) return 3;
+ if (ent->IsKind(STANDARD_TYPE(StepShape_DimensionalSize))) return 4;
+ if (ent->IsKind(STANDARD_TYPE(StepDimTol_GeometricTolerance))) return 5;
+ if (ent->IsKind(STANDARD_TYPE(StepBasic_Group))) return 6;
+ if (ent->IsKind(STANDARD_TYPE(StepBasic_ProductCategory))) return 8;
+ if (ent->IsKind(STANDARD_TYPE(StepRepr_PropertyDefinition))) return 9;
+ if (ent->IsKind(STANDARD_TYPE(StepRepr_Representation))) return 10;
+ if (ent->IsKind(STANDARD_TYPE(StepRepr_ShapeAspect))) return 11;
+ if (ent->IsKind(STANDARD_TYPE(StepRepr_ShapeAspectRelationship))) return 12;
+ return 0;
+}
+
+Handle(StepBasic_Action) StepAP242_IdAttributeSelect::Action() const
+{ return GetCasted(StepBasic_Action,Value()); }
+
+Handle(StepBasic_Address) StepAP242_IdAttributeSelect::Address() const
+{ return GetCasted(StepBasic_Address,Value()); }
+
+Handle(StepBasic_ApplicationContext) StepAP242_IdAttributeSelect::ApplicationContext() const
+{ return GetCasted(StepBasic_ApplicationContext,Value()); }
+
+Handle(StepShape_DimensionalSize) StepAP242_IdAttributeSelect::DimensionalSize() const
+{ return GetCasted(StepShape_DimensionalSize,Value()); }
+
+Handle(StepDimTol_GeometricTolerance) StepAP242_IdAttributeSelect::GeometricTolerance() const
+{ return GetCasted(StepDimTol_GeometricTolerance,Value()); }
+
+Handle(StepBasic_Group) StepAP242_IdAttributeSelect::Group() const
+{ return GetCasted(StepBasic_Group,Value()); }
+
+Handle(StepBasic_ProductCategory) StepAP242_IdAttributeSelect::ProductCategory() const
+{ return GetCasted(StepBasic_ProductCategory,Value()); }
+
+Handle(StepRepr_PropertyDefinition) StepAP242_IdAttributeSelect::PropertyDefinition() const
+{ return GetCasted(StepRepr_PropertyDefinition,Value()); }
+
+Handle(StepRepr_Representation) StepAP242_IdAttributeSelect::Representation() const
+{ return GetCasted(StepRepr_Representation,Value()); }
+
+Handle(StepRepr_ShapeAspect) StepAP242_IdAttributeSelect::ShapeAspect() const
+{ return GetCasted(StepRepr_ShapeAspect,Value()); }
+
+Handle(StepRepr_ShapeAspectRelationship) StepAP242_IdAttributeSelect::ShapeAspectRelationship() const
+{ return GetCasted(StepRepr_ShapeAspectRelationship,Value()); }
+
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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 _StepAP242_IdAttributeSelect_HeaderFile
+#define _StepAP242_IdAttributeSelect_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <StepData_SelectType.hxx>
+#include <Standard_Integer.hxx>
+class Standard_Transient;
+class StepBasic_Action;
+class StepBasic_Address;
+class StepBasic_ApplicationContext;
+class StepShape_DimensionalSize;
+class StepDimTol_GeometricTolerance;
+class StepBasic_Group;
+class StepBasic_ProductCategory;
+class StepRepr_PropertyDefinition;
+class StepRepr_Representation;
+class StepRepr_ShapeAspect;
+class StepRepr_ShapeAspectRelationship;
+
+class StepAP242_IdAttributeSelect : public StepData_SelectType
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ //! Returns a IdAttributeSelect select type
+ Standard_EXPORT StepAP242_IdAttributeSelect();
+
+ //! Recognizes a IdAttributeSelect Kind Entity that is :
+ //! 1 -> Action
+ //! 2 -> Address
+ //! 3 -> ApplicationContext
+ //! 4 -> DimensionalSize
+ //! 5 -> GeometricTolerance
+ //! 6 -> Group
+ //! 7 -> Reserved for OrganizatonalProject (not implemented in OCCT)
+ //! 8 -> ProductCategory
+ //! 9 -> PropertyDefinition
+ //! 10 -> Representation
+ //! 11 -> ShapeAspect
+ //! 12 -> ShapeAspectRelationship
+ //! 0 else
+ Standard_EXPORT Standard_Integer CaseNum (const Handle(Standard_Transient)& ent) const;
+
+ //! returns Value as a Action (Null if another type)
+ Standard_EXPORT Handle(StepBasic_Action) Action() const;
+
+ //! returns Value as a Address (Null if another type)
+ Standard_EXPORT Handle(StepBasic_Address) Address() const;
+
+ //! returns Value as a ApplicationContext (Null if another type)
+ Standard_EXPORT Handle(StepBasic_ApplicationContext) ApplicationContext() const;
+
+ //! returns Value as a DimensionalSize (Null if another type)
+ Standard_EXPORT Handle(StepShape_DimensionalSize) DimensionalSize() const;
+
+ //! returns Value as a GeometricTolerance (Null if another type)
+ Standard_EXPORT Handle(StepDimTol_GeometricTolerance) GeometricTolerance() const;
+
+ //! returns Value as a Group (Null if another type)
+ Standard_EXPORT Handle(StepBasic_Group) Group() const;
+
+ //! returns Value as a ProductCategory (Null if another type)
+ Standard_EXPORT Handle(StepBasic_ProductCategory) ProductCategory() const;
+
+ //! returns Value as a PropertyDefinition (Null if another type)
+ Standard_EXPORT Handle(StepRepr_PropertyDefinition) PropertyDefinition() const;
+
+ //! returns Value as a Representation (Null if another type)
+ Standard_EXPORT Handle(StepRepr_Representation) Representation() const;
+
+ //! returns Value as a ShapeAspect (Null if another type)
+ Standard_EXPORT Handle(StepRepr_ShapeAspect) ShapeAspect() const;
+
+ //! returns Value as a ShapeAspectRelationship (Null if another type)
+ Standard_EXPORT Handle(StepRepr_ShapeAspectRelationship) ShapeAspectRelationship() const;
+};
+#endif // _StepAP242_IdAttributeSelect_HeaderFile
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepAP242_ItemIdentifiedRepresentationUsage.hxx>
+
+#include <StepAP242_ItemIdentifiedRepresentationUsageDefinition.hxx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+
+//=======================================================================
+//function : StepAP242_ItemIdentifiedRepresentationUsage
+//purpose :
+//=======================================================================
+
+StepAP242_ItemIdentifiedRepresentationUsage::StepAP242_ItemIdentifiedRepresentationUsage () {}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepAP242_ItemIdentifiedRepresentationUsage::Init(
+ const Handle(TCollection_HAsciiString)& theName,
+ const Handle(TCollection_HAsciiString)& theDescription,
+ const StepAP242_ItemIdentifiedRepresentationUsageDefinition& theDefinition,
+ const Handle(StepRepr_Representation)& theUsedRepresentation,
+ const Handle(StepRepr_HArray1OfRepresentationItem)& theIdentifiedItem)
+{
+ // --- classe own fields ---
+ name = theName;
+ description = theDescription;
+ definition = theDefinition;
+ usedRepresentation = theUsedRepresentation;
+ identifiedItem = theIdentifiedItem;
+}
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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 _StepAP242_ItemIdentifiedRepresentationUsage_HeaderFile
+#define _StepAP242_ItemIdentifiedRepresentationUsage_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <MMgt_TShared.hxx>
+#include <StepAP242_ItemIdentifiedRepresentationUsageDefinition.hxx>
+#include <Standard_Integer.hxx>
+#include <StepRepr_HArray1OfRepresentationItem.hxx>
+
+class TCollection_HAsciiString;
+class StepRepr_Representation;
+class StepAP242_ItemIdentifiedRepresentationUsageDefinition;
+class StepRepr_RepresentationItem;
+
+class StepAP242_ItemIdentifiedRepresentationUsage;
+DEFINE_STANDARD_HANDLE(StepAP242_ItemIdentifiedRepresentationUsage, MMgt_TShared)
+class StepAP242_ItemIdentifiedRepresentationUsage : public MMgt_TShared
+{
+
+public:
+
+ //! Returns a ItemIdentifiedRepresentationUsage
+ Standard_EXPORT StepAP242_ItemIdentifiedRepresentationUsage();
+
+ //! Init all fields own and inherited
+ Standard_EXPORT virtual void Init (const Handle(TCollection_HAsciiString)& theName, const Handle(TCollection_HAsciiString)& theDescription, const StepAP242_ItemIdentifiedRepresentationUsageDefinition& theDefinition, const Handle(StepRepr_Representation)& theUsedRepresentation, const Handle(StepRepr_HArray1OfRepresentationItem)& theIdentifiedItem) ;
+
+ //! Set field Name
+ inline void SetName(const Handle(TCollection_HAsciiString)& theName)
+ {
+ name = theName;
+ }
+
+ //! Returns field Name
+ inline Handle(TCollection_HAsciiString) Name() const
+ {
+ return name;
+ }
+
+ //! Set field Description
+ inline void SetDescription(const Handle(TCollection_HAsciiString)& theDescription)
+ {
+ description = theDescription;
+ }
+
+ //! Returns field Description
+ inline Handle(TCollection_HAsciiString) Description() const
+ {
+ return description;
+ }
+
+ //! Set field Definition
+ inline void SetDefinition(const StepAP242_ItemIdentifiedRepresentationUsageDefinition& theDefinition)
+ {
+ definition = theDefinition;
+ }
+
+ //! Returns field Definition
+ inline StepAP242_ItemIdentifiedRepresentationUsageDefinition Definition() const
+ {
+ return definition;
+ }
+
+ //! Set field UsedRepresentation
+ inline void SetUsedRepresentation(const Handle(StepRepr_Representation)& theUsedRepresentation)
+ {
+ usedRepresentation = theUsedRepresentation;
+ }
+
+ //! Retuns field UsedRepresentation
+ inline Handle(StepRepr_Representation) UsedRepresentation() const
+ {
+ return usedRepresentation;
+ }
+
+ //! Returns field IdentifiedItem
+ inline Handle(StepRepr_HArray1OfRepresentationItem) IdentifiedItem () const
+ {
+ return identifiedItem;
+ }
+
+ //! Returns number of identified items
+ inline Standard_Integer NbIdentifiedItem () const
+ {
+ return (identifiedItem.IsNull() ? 0 : identifiedItem->Length());
+ }
+
+ //! Set fiels IdentifiedItem
+ inline void SetIdentifiedItem (const Handle(StepRepr_HArray1OfRepresentationItem)& theIdentifiedItem)
+ {
+ identifiedItem = theIdentifiedItem;
+ }
+
+ //! Returns identified item with given number
+ inline Handle(StepRepr_RepresentationItem) IdentifiedItemValue
+ (const Standard_Integer num) const
+ {
+ return identifiedItem->Value(num);
+ }
+
+ //! Set identified item with given number
+ inline void SetIdentifiedItemValue (const Standard_Integer num, const Handle(StepRepr_RepresentationItem)& theItem)
+ {
+ identifiedItem->SetValue (num, theItem);
+ }
+
+ DEFINE_STANDARD_RTTI(StepAP242_ItemIdentifiedRepresentationUsage, MMgt_TShared)
+
+private:
+ Handle(TCollection_HAsciiString) name;
+ Handle(TCollection_HAsciiString) description;
+ StepAP242_ItemIdentifiedRepresentationUsageDefinition definition;
+ Handle(StepRepr_Representation) usedRepresentation;
+ Handle(StepRepr_HArray1OfRepresentationItem) identifiedItem;
+};
+#endif // _StepAP242_ItemIdentifiedRepresentationUsage_HeaderFile
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepAP242_ItemIdentifiedRepresentationUsageDefinition.hxx>
+#include <Interface_Macros.hxx>
+#include <StepAP214_AppliedApprovalAssignment.hxx>
+#include <StepAP214_AppliedDateAndTimeAssignment.hxx>
+#include <StepAP214_AppliedDateAssignment.hxx>
+#include <StepAP214_AppliedDocumentReference.hxx>
+#include <StepAP214_AppliedExternalIdentificationAssignment.hxx>
+#include <StepAP214_AppliedGroupAssignment.hxx>
+#include <StepAP214_AppliedOrganizationAssignment.hxx>
+#include <StepAP214_AppliedPersonAndOrganizationAssignment.hxx>
+#include <StepAP214_AppliedSecurityClassificationAssignment.hxx>
+#include <StepBasic_GeneralProperty.hxx>
+#include <StepBasic_ProductDefinitionRelationship.hxx>
+#include <StepDimTol_GeometricTolerance.hxx>
+#include <StepRepr_PropertyDefinition.hxx>
+#include <StepRepr_PropertyDefinitionRelationship.hxx>
+#include <StepRepr_ShapeAspect.hxx>
+#include <StepRepr_ShapeAspectRelationship.hxx>
+#include <StepShape_DimensionalSize.hxx>
+
+//=======================================================================
+//function : StepAP242_ItemIdentifiedRepresentationUsageDefinition
+//purpose :
+//=======================================================================
+
+StepAP242_ItemIdentifiedRepresentationUsageDefinition::
+ StepAP242_ItemIdentifiedRepresentationUsageDefinition () { }
+
+//=======================================================================
+//function : CaseNum
+//purpose :
+//=======================================================================
+
+Standard_Integer StepAP242_ItemIdentifiedRepresentationUsageDefinition::
+ CaseNum(const Handle(Standard_Transient)& ent) const
+{
+ if (ent.IsNull()) return 0;
+ if (ent->IsKind(STANDARD_TYPE(StepAP214_AppliedApprovalAssignment))) return 1;
+ if (ent->IsKind(STANDARD_TYPE(StepAP214_AppliedDateAndTimeAssignment))) return 2;
+ if (ent->IsKind(STANDARD_TYPE(StepAP214_AppliedDateAssignment))) return 3;
+ if (ent->IsKind(STANDARD_TYPE(StepAP214_AppliedDocumentReference))) return 4;
+ if (ent->IsKind(STANDARD_TYPE(StepAP214_AppliedExternalIdentificationAssignment))) return 5;
+ if (ent->IsKind(STANDARD_TYPE(StepAP214_AppliedGroupAssignment))) return 6;
+ if (ent->IsKind(STANDARD_TYPE(StepAP214_AppliedOrganizationAssignment))) return 7;
+ if (ent->IsKind(STANDARD_TYPE(StepAP214_AppliedPersonAndOrganizationAssignment))) return 8;
+ if (ent->IsKind(STANDARD_TYPE(StepAP214_AppliedSecurityClassificationAssignment))) return 9;
+ if (ent->IsKind(STANDARD_TYPE(StepShape_DimensionalSize))) return 10;
+ if (ent->IsKind(STANDARD_TYPE(StepBasic_GeneralProperty))) return 11;
+ if (ent->IsKind(STANDARD_TYPE(StepDimTol_GeometricTolerance))) return 12;
+ if (ent->IsKind(STANDARD_TYPE(StepBasic_ProductDefinitionRelationship))) return 13;
+ if (ent->IsKind(STANDARD_TYPE(StepRepr_PropertyDefinition))) return 14;
+ if (ent->IsKind(STANDARD_TYPE(StepRepr_PropertyDefinitionRelationship))) return 15;
+ if (ent->IsKind(STANDARD_TYPE(StepRepr_ShapeAspect))) return 16;
+ if (ent->IsKind(STANDARD_TYPE(StepRepr_ShapeAspectRelationship))) return 17;
+ return 0;
+}
+
+Handle(StepAP214_AppliedApprovalAssignment) StepAP242_ItemIdentifiedRepresentationUsageDefinition::AppliedApprovalAssignment() const
+{ return GetCasted(StepAP214_AppliedApprovalAssignment,Value()); }
+
+Handle(StepAP214_AppliedDateAndTimeAssignment) StepAP242_ItemIdentifiedRepresentationUsageDefinition::AppliedDateAndTimeAssignment() const
+{ return GetCasted(StepAP214_AppliedDateAndTimeAssignment,Value()); }
+
+Handle(StepAP214_AppliedDateAssignment) StepAP242_ItemIdentifiedRepresentationUsageDefinition::AppliedDateAssignment() const
+{ return GetCasted(StepAP214_AppliedDateAssignment,Value()); }
+
+Handle(StepAP214_AppliedDocumentReference) StepAP242_ItemIdentifiedRepresentationUsageDefinition::AppliedDocumentReference() const
+{ return GetCasted(StepAP214_AppliedDocumentReference,Value()); }
+
+Handle(StepAP214_AppliedExternalIdentificationAssignment) StepAP242_ItemIdentifiedRepresentationUsageDefinition::AppliedExternalIdentificationAssignment() const
+{ return GetCasted(StepAP214_AppliedExternalIdentificationAssignment,Value()); }
+
+Handle(StepAP214_AppliedGroupAssignment) StepAP242_ItemIdentifiedRepresentationUsageDefinition::AppliedGroupAssignment() const
+{ return GetCasted(StepAP214_AppliedGroupAssignment,Value()); }
+
+Handle(StepAP214_AppliedOrganizationAssignment) StepAP242_ItemIdentifiedRepresentationUsageDefinition::AppliedOrganizationAssignment() const
+{ return GetCasted(StepAP214_AppliedOrganizationAssignment,Value()); }
+
+Handle(StepAP214_AppliedPersonAndOrganizationAssignment) StepAP242_ItemIdentifiedRepresentationUsageDefinition::AppliedPersonAndOrganizationAssignment() const
+{ return GetCasted(StepAP214_AppliedPersonAndOrganizationAssignment,Value()); }
+
+Handle(StepAP214_AppliedSecurityClassificationAssignment) StepAP242_ItemIdentifiedRepresentationUsageDefinition::AppliedSecurityClassificationAssignment() const
+{ return GetCasted(StepAP214_AppliedSecurityClassificationAssignment,Value()); }
+
+Handle(StepShape_DimensionalSize) StepAP242_ItemIdentifiedRepresentationUsageDefinition::DimensionalSize() const
+{ return GetCasted(StepShape_DimensionalSize,Value()); }
+
+Handle(StepBasic_GeneralProperty) StepAP242_ItemIdentifiedRepresentationUsageDefinition::GeneralProperty() const
+{ return GetCasted(StepBasic_GeneralProperty,Value()); }
+
+Handle(StepDimTol_GeometricTolerance) StepAP242_ItemIdentifiedRepresentationUsageDefinition::GeometricTolerance() const
+{ return GetCasted(StepDimTol_GeometricTolerance,Value()); }
+
+Handle(StepBasic_ProductDefinitionRelationship) StepAP242_ItemIdentifiedRepresentationUsageDefinition::ProductDefinitionRelationship() const
+{ return GetCasted(StepBasic_ProductDefinitionRelationship,Value()); }
+
+Handle(StepRepr_PropertyDefinition) StepAP242_ItemIdentifiedRepresentationUsageDefinition::PropertyDefinition() const
+{ return GetCasted(StepRepr_PropertyDefinition,Value()); }
+
+Handle(StepRepr_PropertyDefinitionRelationship) StepAP242_ItemIdentifiedRepresentationUsageDefinition::PropertyDefinitionRelationship() const
+{ return GetCasted(StepRepr_PropertyDefinitionRelationship,Value()); }
+
+Handle(StepRepr_ShapeAspect) StepAP242_ItemIdentifiedRepresentationUsageDefinition::ShapeAspect() const
+{ return GetCasted(StepRepr_ShapeAspect,Value()); }
+
+Handle(StepRepr_ShapeAspectRelationship) StepAP242_ItemIdentifiedRepresentationUsageDefinition::ShapeAspectRelationship() const
+{ return GetCasted(StepRepr_ShapeAspectRelationship,Value()); }
+
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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 _StepAP242_ItemIdentifiedRepresentationUsageDefinition_HeaderFile
+#define _StepAP242_ItemIdentifiedRepresentationUsageDefinition_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <StepData_SelectType.hxx>
+#include <Standard_Integer.hxx>
+class Standard_Transient;
+class StepAP214_AppliedApprovalAssignment;
+class StepAP214_AppliedDateAndTimeAssignment;
+class StepAP214_AppliedDateAssignment;
+class StepAP214_AppliedDocumentReference;
+class StepAP214_AppliedExternalIdentificationAssignment;
+class StepAP214_AppliedGroupAssignment;
+class StepAP214_AppliedOrganizationAssignment;
+class StepAP214_AppliedPersonAndOrganizationAssignment;
+class StepAP214_AppliedSecurityClassificationAssignment;
+class StepShape_DimensionalSize;
+class StepBasic_GeneralProperty;
+class StepDimTol_GeometricTolerance;
+class StepBasic_ProductDefinitionRelationship;
+class StepRepr_PropertyDefinition;
+class StepRepr_PropertyDefinitionRelationship;
+class StepRepr_ShapeAspect;
+class StepRepr_ShapeAspectRelationship;
+
+class StepAP242_ItemIdentifiedRepresentationUsageDefinition : public StepData_SelectType
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ //! Returns a ItemIdentifiedRepresentationUsageDefinition select type
+ Standard_EXPORT StepAP242_ItemIdentifiedRepresentationUsageDefinition();
+
+ //! Recognizes a ItemIdentifiedRepresentationUsageDefinition Kind Entity that is :
+ //! 1 -> AppliedApprovalAssignment
+ //! 2 -> AppliedDateAndTimeAssignment
+ //! 3 -> AppliedDateAssignment
+ //! 4 -> AppliedDocumentReference
+ //! 5 -> AppliedExternalIdentificationAssignment
+ //! 6 -> AppliedGroupAssignment
+ //! 7 -> AppliedOrganizationAssignment
+ //! 8 -> AppliedPersonAndOrganizationAssignment
+ //! 9 -> AppliedSecurityClassificationAssignment
+ //! 10 -> DimensionalSize
+ //! 11 -> GeneralProperty
+ //! 12 -> GeometricTolerance
+ //! 13 -> ProductDefinitionRelationship
+ //! 14 -> PropertyDefinition
+ //! 15 -> PropertyDefinitionRelationship
+ //! 16 -> ShapeAspect
+ //! 17 -> ShapeAspectRelationship
+ //! 0 else
+ Standard_EXPORT Standard_Integer CaseNum (const Handle(Standard_Transient)& ent) const;
+
+ //! returns Value as a AppliedApprovalAssignment (Null if another type)
+ Standard_EXPORT Handle(StepAP214_AppliedApprovalAssignment) AppliedApprovalAssignment() const;
+
+ //! returns Value as a AppliedDateAndTimeAssignment (Null if another type)
+ Standard_EXPORT Handle(StepAP214_AppliedDateAndTimeAssignment) AppliedDateAndTimeAssignment() const;
+
+ //! returns Value as a AppliedDateAssignment (Null if another type)
+ Standard_EXPORT Handle(StepAP214_AppliedDateAssignment) AppliedDateAssignment() const;
+
+ //! returns Value as a AppliedDocumentReference (Null if another type)
+ Standard_EXPORT Handle(StepAP214_AppliedDocumentReference) AppliedDocumentReference() const;
+
+ //! returns Value as a AppliedExternalIdentificationAssignment (Null if another type)
+ Standard_EXPORT Handle(StepAP214_AppliedExternalIdentificationAssignment) AppliedExternalIdentificationAssignment() const;
+
+ //! returns Value as a AppliedGroupAssignment (Null if another type)
+ Standard_EXPORT Handle(StepAP214_AppliedGroupAssignment) AppliedGroupAssignment() const;
+
+ //! returns Value as a AppliedOrganizationAssignment (Null if another type)
+ Standard_EXPORT Handle(StepAP214_AppliedOrganizationAssignment) AppliedOrganizationAssignment() const;
+
+ //! returns Value as a AppliedPersonAndOrganizationAssignment (Null if another type)
+ Standard_EXPORT Handle(StepAP214_AppliedPersonAndOrganizationAssignment) AppliedPersonAndOrganizationAssignment() const;
+
+ //! returns Value as a AppliedSecurityClassificationAssignment (Null if another type)
+ Standard_EXPORT Handle(StepAP214_AppliedSecurityClassificationAssignment) AppliedSecurityClassificationAssignment() const;
+
+ //! returns Value as a DimensionalSize (Null if another type)
+ Standard_EXPORT Handle(StepShape_DimensionalSize) DimensionalSize() const;
+
+ //! returns Value as a GeneralProperty (Null if another type)
+ Standard_EXPORT Handle(StepBasic_GeneralProperty) GeneralProperty() const;
+
+ //! returns Value as a GeometricTolerance (Null if another type)
+ Standard_EXPORT Handle(StepDimTol_GeometricTolerance) GeometricTolerance() const;
+
+ //! returns Value as a ProductDefinitionRelationship (Null if another type)
+ Standard_EXPORT Handle(StepBasic_ProductDefinitionRelationship) ProductDefinitionRelationship() const;
+
+ //! returns Value as a PropertyDefinition (Null if another type)
+ Standard_EXPORT Handle(StepRepr_PropertyDefinition) PropertyDefinition() const;
+
+ //! returns Value as a PropertyDefinitionRelationship (Null if another type)
+ Standard_EXPORT Handle(StepRepr_PropertyDefinitionRelationship) PropertyDefinitionRelationship() const;
+
+ //! returns Value as a ShapeAspect (Null if another type)
+ Standard_EXPORT Handle(StepRepr_ShapeAspect) ShapeAspect() const;
+
+ //! returns Value as a ShapeAspectRelationship (Null if another type)
+ Standard_EXPORT Handle(StepRepr_ShapeAspectRelationship) ShapeAspectRelationship() const;
+
+};
+#endif // _StepAP242_ItemIdentifiedRepresentationUsageDefinition_HeaderFile
case 12 : return "VOLUME_MEASURE";
case 13 : return "MASS_MEASURE";
case 14 : return "THERMODYNAMIC_TEMPERATURE_MEASURE";
+ case 15 : return "COUNT_MEASURE";
default : break;
}
return "";
else if (name[0] == 'S' && !strcmp (name,"SOLID_ANGLE_MEASURE")) thecase = 4;
else if (name[2] == 'T' && !strcmp (name,"RATIO_MEASURE")) thecase = 5;
else if (name[2] == 'R' && !strcmp (name,"PARAMETER_VALUE")) thecase = 6;
- else if (name[0] == 'C' && !strcmp (name,"CONTEXT_DEPENDANT_MEASURE")) thecase = 7;
+ else if (name[3] == 'T' && !strcmp (name,"CONTEXT_DEPENDANT_MEASURE")) thecase = 7;
else if (name[9] == 'L' && !strcmp (name,"POSITIVE_LENGTH_MEASURE")) thecase = 8;
else if (name[9] == 'P' && !strcmp (name,"POSITIVE_PLANE_ANGLE_MEASURE")) thecase = 9;
else if (name[9] == 'R' && !strcmp (name,"POSITIVE_RATIO_MEASURE")) thecase = 10;
else if (name[0] == 'V' && !strcmp (name,"VOLUME_MEASURE")) thecase = 12;
else if (name[0] == 'M' && !strcmp (name,"MASS_MEASURE")) thecase = 13;
else if (name[1] == 'H' && !strcmp (name,"THERMODYNAMIC_TEMPERATURE_MEASURE")) thecase = 14;
+ else if (name[2] == 'U' && !strcmp (name,"COUNT_MEASURE")) thecase = 15;
else return Standard_False;
return Standard_True;
//! solid_angle_measure,ratio_measure,parameter_value,
//! context_dependent_measure,positive_length_measure,
//! positive_plane_angle_measure,positive_ratio_measure,
-//! area_measure,volume_measure
+//! area_measure,volume_measure, count_measure
class StepBasic_MeasureValueMember : public StepData_SelectReal
{
StepDimTol_AngularityTolerance.cxx
StepDimTol_AngularityTolerance.hxx
+StepDimTol_AreaUnitType.hxx
StepDimTol_Array1OfDatumReference.hxx
+StepDimTol_Array1OfDatumReferenceCompartment.hxx
+StepDimTol_Array1OfDatumReferenceElement.hxx
+StepDimTol_Array1OfDatumReferenceModifier.hxx
+StepDimTol_Array1OfDatumSystemOrReference.hxx
+StepDimTol_Array1OfGeometricToleranceModifier.hxx
+StepDimTol_Array1OfToleranceZoneTarget.hxx
StepDimTol_CircularRunoutTolerance.cxx
StepDimTol_CircularRunoutTolerance.hxx
StepDimTol_CoaxialityTolerance.cxx
StepDimTol_Datum.hxx
StepDimTol_DatumFeature.cxx
StepDimTol_DatumFeature.hxx
+StepDimTol_DatumOrCommonDatum.cxx
+StepDimTol_DatumOrCommonDatum.hxx
StepDimTol_DatumReference.cxx
StepDimTol_DatumReference.hxx
+StepDimTol_DatumReferenceCompartment.cxx
+StepDimTol_DatumReferenceCompartment.hxx
+StepDimTol_DatumReferenceElement.cxx
+StepDimTol_DatumReferenceElement.hxx
+StepDimTol_DatumReferenceModifier.cxx
+StepDimTol_DatumReferenceModifier.hxx
+StepDimTol_DatumReferenceModifierWithValue.cxx
+StepDimTol_DatumReferenceModifierWithValue.hxx
+StepDimTol_DatumReferenceModifierType.hxx
+StepDimTol_DatumSystem.cxx
+StepDimTol_DatumSystem.hxx
+StepDimTol_DatumSystemOrReference.cxx
+StepDimTol_DatumSystemOrReference.hxx
StepDimTol_DatumTarget.cxx
StepDimTol_DatumTarget.hxx
StepDimTol_FlatnessTolerance.cxx
StepDimTol_FlatnessTolerance.hxx
+StepDimTol_GeneralDatumReference.cxx
+StepDimTol_GeneralDatumReference.hxx
StepDimTol_GeometricTolerance.cxx
StepDimTol_GeometricTolerance.hxx
+StepDimTol_GeometricToleranceModifier.hxx
StepDimTol_GeometricToleranceRelationship.cxx
StepDimTol_GeometricToleranceRelationship.hxx
+StepDimTol_GeometricToleranceTarget.cxx
+StepDimTol_GeometricToleranceTarget.hxx
+StepDimTol_GeometricToleranceType.hxx
StepDimTol_GeometricToleranceWithDatumReference.cxx
StepDimTol_GeometricToleranceWithDatumReference.hxx
+StepDimTol_GeometricToleranceWithDefinedAreaUnit.cxx
+StepDimTol_GeometricToleranceWithDefinedAreaUnit.hxx
+StepDimTol_GeometricToleranceWithDefinedUnit.cxx
+StepDimTol_GeometricToleranceWithDefinedUnit.hxx
+StepDimTol_GeometricToleranceWithMaximumTolerance.cxx
+StepDimTol_GeometricToleranceWithMaximumTolerance.hxx
+StepDimTol_GeometricToleranceWithModifiers.cxx
+StepDimTol_GeometricToleranceWithModifiers.hxx
+StepDimTol_GeoTolAndGeoTolWthDatRef.cxx
+StepDimTol_GeoTolAndGeoTolWthDatRef.hxx
+StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod.cxx
+StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod.hxx
StepDimTol_GeoTolAndGeoTolWthDatRefAndModGeoTolAndPosTol.cxx
StepDimTol_GeoTolAndGeoTolWthDatRefAndModGeoTolAndPosTol.hxx
+StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol.cxx
+StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol.hxx
+StepDimTol_GeoTolAndGeoTolWthMod.cxx
+StepDimTol_GeoTolAndGeoTolWthMod.hxx
StepDimTol_HArray1OfDatumReference.hxx
+StepDimTol_HArray1OfDatumReferenceCompartment.hxx
+StepDimTol_HArray1OfDatumReferenceElement.hxx
+StepDimTol_HArray1OfDatumReferenceModifier.hxx
+StepDimTol_HArray1OfDatumSystemOrReference.hxx
+StepDimTol_HArray1OfGeometricToleranceModifier.hxx
+StepDimTol_HArray1OfToleranceZoneTarget.hxx
StepDimTol_LimitCondition.hxx
StepDimTol_LineProfileTolerance.cxx
StepDimTol_LineProfileTolerance.hxx
StepDimTol_ModifiedGeometricTolerance.cxx
StepDimTol_ModifiedGeometricTolerance.hxx
+StepDimTol_NonUniformZoneDefinition.cxx
+StepDimTol_NonUniformZoneDefinition.hxx
StepDimTol_ParallelismTolerance.cxx
StepDimTol_ParallelismTolerance.hxx
StepDimTol_PerpendicularityTolerance.cxx
StepDimTol_PlacedDatumTargetFeature.hxx
StepDimTol_PositionTolerance.cxx
StepDimTol_PositionTolerance.hxx
+StepDimTol_ProjectedZoneDefinition.cxx
+StepDimTol_ProjectedZoneDefinition.hxx
StepDimTol_RoundnessTolerance.cxx
StepDimTol_RoundnessTolerance.hxx
+StepDimTol_RunoutZoneDefinition.cxx
+StepDimTol_RunoutZoneDefinition.hxx
+StepDimTol_RunoutZoneOrientation.cxx
+StepDimTol_RunoutZoneOrientation.hxx
StepDimTol_ShapeToleranceSelect.cxx
StepDimTol_ShapeToleranceSelect.hxx
+StepDimTol_SimpleDatumReferenceModifier.hxx
+StepDimTol_SimpleDatumReferenceModifierMember.cxx
+StepDimTol_SimpleDatumReferenceModifierMember.hxx
StepDimTol_StraightnessTolerance.cxx
StepDimTol_StraightnessTolerance.hxx
StepDimTol_SurfaceProfileTolerance.cxx
StepDimTol_SurfaceProfileTolerance.hxx
StepDimTol_SymmetryTolerance.cxx
StepDimTol_SymmetryTolerance.hxx
+StepDimTol_ToleranceZone.cxx
+StepDimTol_ToleranceZone.hxx
+StepDimTol_ToleranceZoneDefinition.cxx
+StepDimTol_ToleranceZoneDefinition.hxx
+StepDimTol_ToleranceZoneForm.cxx
+StepDimTol_ToleranceZoneForm.hxx
+StepDimTol_ToleranceZoneTarget.cxx
+StepDimTol_ToleranceZoneTarget.hxx
StepDimTol_TotalRunoutTolerance.cxx
StepDimTol_TotalRunoutTolerance.hxx
+StepDimTol_UnequallyDisposedGeometricTolerance.cxx
+StepDimTol_UnequallyDisposedGeometricTolerance.hxx
\ No newline at end of file
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_AreaUnitType_HeaderFile
+#define _StepDimTol_AreaUnitType_HeaderFile
+
+#include <Standard_PrimitiveTypes.hxx>
+
+enum StepDimTol_AreaUnitType {
+ StepDimTol_Circular,
+ StepDimTol_Rectangular,
+ StepDimTol_Square
+};
+
+#endif
\ No newline at end of file
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_Array1OfDatumReferenceCompartment_HeaderFile
+#define _StepDimTol_Array1OfDatumReferenceCompartment_HeaderFile
+
+#include <StepDimTol_DatumReferenceCompartment.hxx>
+#include <NCollection_Array1.hxx>
+
+typedef NCollection_Array1<Handle(StepDimTol_DatumReferenceCompartment)> StepDimTol_Array1OfDatumReferenceCompartment;
+#endif // _StepDimTol_Array1OfDatumReferenceCompartment_HeaderFile
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_Array1OfDatumReferenceElement_HeaderFile
+#define _StepDimTol_Array1OfDatumReferenceElement_HeaderFile
+
+#include <StepDimTol_DatumReferenceElement.hxx>
+#include <NCollection_Array1.hxx>
+
+typedef NCollection_Array1<Handle(StepDimTol_DatumReferenceElement)> StepDimTol_Array1OfDatumReferenceElement;
+#endif // _StepDimTol_Array1OfDatumReferenceElement_HeaderFile
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_Array1OfDatumReferenceModifier_HeaderFile
+#define _StepDimTol_Array1OfDatumReferenceModifier_HeaderFile
+
+#include <StepDimTol_DatumReferenceModifier.hxx>
+#include <NCollection_Array1.hxx>
+
+typedef NCollection_Array1<StepDimTol_DatumReferenceModifier> StepDimTol_Array1OfDatumReferenceModifier;
+#endif // _StepDimTol_Array1OfDatumReferenceModifier_HeaderFile
--- /dev/null
+// Created on: 2015-07-21
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_Array1OfDatumSystemOrReference_HeaderFile
+#define _StepDimTol_Array1OfDatumSystemOrReference_HeaderFile
+
+#include <StepDimTol_DatumSystemOrReference.hxx>
+#include <NCollection_Array1.hxx>
+
+typedef NCollection_Array1<StepDimTol_DatumSystemOrReference> StepDimTol_Array1OfDatumSystemOrReference;
+#endif // _StepDimTol_Array1OfDatumSystemOrReference_HeaderFile
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_Array1OfGeometricToleranceModifier_HeaderFile
+#define _StepDimTol_Array1OfGeometricToleranceModifier_HeaderFile
+
+#include <StepDimTol_GeometricToleranceModifier.hxx>
+#include <NCollection_Array1.hxx>
+
+typedef NCollection_Array1<StepDimTol_GeometricToleranceModifier> StepDimTol_Array1OfGeometricToleranceModifier;
+
+#endif // _StepDimTol_Array1OfGeometricToleranceModifier_HeaderFile
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_Array1OfToleranceZoneTarget_HeaderFile
+#define _StepDimTol_Array1OfToleranceZoneTarget_HeaderFile
+
+#include <StepDimTol_ToleranceZoneTarget.hxx>
+#include <NCollection_Array1.hxx>
+
+typedef NCollection_Array1<StepDimTol_ToleranceZoneTarget> StepDimTol_Array1OfToleranceZoneTarget;
+#endif // _StepDimTol_Array1OfToleranceZoneTarget_HeaderFile
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepDimTol_DatumOrCommonDatum.hxx>
+
+#include <Interface_Macros.hxx>
+#include <StepDimTol_Datum.hxx>
+#include <StepDimTol_HArray1OfDatumReferenceElement.hxx>
+
+//=======================================================================
+//function : StepDimTol_DatumOrCommonDatum
+//purpose :
+//=======================================================================
+
+StepDimTol_DatumOrCommonDatum::StepDimTol_DatumOrCommonDatum () { }
+
+//=======================================================================
+//function : CaseNum
+//purpose :
+//=======================================================================
+
+Standard_Integer StepDimTol_DatumOrCommonDatum::CaseNum(const Handle(Standard_Transient)& ent) const
+{
+ if (ent.IsNull()) return 0;
+ if (ent->IsKind(STANDARD_TYPE(StepDimTol_Datum))) return 1;
+ if (ent->IsKind(STANDARD_TYPE(StepDimTol_HArray1OfDatumReferenceElement))) return 2;
+ return 0;
+}
+
+Handle(StepDimTol_Datum) StepDimTol_DatumOrCommonDatum::Datum() const
+{ return GetCasted(StepDimTol_Datum,Value()); }
+
+Handle(StepDimTol_HArray1OfDatumReferenceElement) StepDimTol_DatumOrCommonDatum::CommonDatumList() const
+{ return GetCasted(StepDimTol_HArray1OfDatumReferenceElement,Value()); }
+
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_DatumOrCommonDatum_HeaderFile
+#define _StepDimTol_DatumOrCommonDatum_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+#include <StepData_SelectType.hxx>
+
+class Standard_Transient;
+class StepDimTol_Datum;
+class StepDimTol_HArray1OfDatumReferenceElement;
+
+class StepDimTol_DatumOrCommonDatum : public StepData_SelectType
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ //! Returns a DatumOrCommonDatum select type
+ Standard_EXPORT StepDimTol_DatumOrCommonDatum();
+
+ //! Recognizes a DatumOrCommonDatum Kind Entity that is :
+ //! 1 -> Datum
+ //! 2 -> CommonDatumList
+ //! 0 else
+ Standard_EXPORT Standard_Integer CaseNum (const Handle(Standard_Transient)& ent) const;
+
+ //! returns Value as a Datum (Null if another type)
+ Standard_EXPORT Handle(StepDimTol_Datum) Datum() const;
+
+ //! returns Value as a CommonDatumList (Null if another type)
+ Standard_EXPORT Handle(StepDimTol_HArray1OfDatumReferenceElement) CommonDatumList() const;
+
+};
+#endif // _StepDimTol_DatumOrCommonDatum_HeaderFile
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepDimTol_DatumReferenceCompartment.hxx>
+
+//=======================================================================
+//function : StepDimTol_DatumReferenceCompartment
+//purpose :
+//=======================================================================
+
+StepDimTol_DatumReferenceCompartment::StepDimTol_DatumReferenceCompartment ()
+{
+}
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_DatumReferenceCompartment_HeaderFile
+#define _StepDimTol_DatumReferenceCompartment_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepDimTol_GeneralDatumReference.hxx>
+
+class StepDimTol_DatumReferenceCompartment;
+DEFINE_STANDARD_HANDLE(StepDimTol_DatumReferenceCompartment, StepDimTol_GeneralDatumReference)
+//! Representation of STEP entity DatumReferenceCompartment
+class StepDimTol_DatumReferenceCompartment : public StepDimTol_GeneralDatumReference
+{
+
+public:
+
+ //! Empty constructor
+ Standard_EXPORT StepDimTol_DatumReferenceCompartment();
+
+ DEFINE_STANDARD_RTTI(StepDimTol_DatumReferenceCompartment, StepDimTol_GeneralDatumReference)
+};
+#endif // _StepDimTol_DatumReferenceCompartment_HeaderFile
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepDimTol_DatumReferenceElement.hxx>
+
+//=======================================================================
+//function : StepDimTol_DatumReferenceElement
+//purpose :
+//=======================================================================
+
+StepDimTol_DatumReferenceElement::StepDimTol_DatumReferenceElement ()
+{
+}
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_DatumReferenceElement_HeaderFile
+#define _StepDimTol_DatumReferenceElement_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineHandle.hxx>
+#include <Standard_Macro.hxx>
+
+#include <StepDimTol_GeneralDatumReference.hxx>
+
+class StepDimTol_DatumReferenceElement;
+DEFINE_STANDARD_HANDLE(StepDimTol_DatumReferenceElement, StepDimTol_GeneralDatumReference)
+//! Representation of STEP entity DatumReferenceElement
+class StepDimTol_DatumReferenceElement : public StepDimTol_GeneralDatumReference
+{
+
+public:
+
+ //! Empty constructor
+ Standard_EXPORT StepDimTol_DatumReferenceElement();
+
+ DEFINE_STANDARD_RTTI(StepDimTol_DatumReferenceElement, StepDimTol_GeneralDatumReference)
+};
+#endif // _StepDimTol_DatumReferenceElement_HeaderFile
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepDimTol_DatumReferenceModifier.hxx>
+#include <Interface_Macros.hxx>
+#include <StepDimTol_DatumReferenceModifierWithValue.hxx>
+#include <StepDimTol_SimpleDatumReferenceModifierMember.hxx>
+
+//=======================================================================
+//function : StepDimTol_DatumReferenceModifier
+//purpose :
+//=======================================================================
+
+StepDimTol_DatumReferenceModifier::StepDimTol_DatumReferenceModifier () { }
+
+//=======================================================================
+//function : CaseNum
+//purpose :
+//=======================================================================
+
+Standard_Integer StepDimTol_DatumReferenceModifier::CaseNum(const Handle(Standard_Transient)& ent) const
+{
+ if (ent.IsNull()) return 0;
+ if (ent->IsKind(STANDARD_TYPE(StepDimTol_DatumReferenceModifierWithValue))) return 1;
+ if (ent->IsKind(STANDARD_TYPE(StepDimTol_SimpleDatumReferenceModifierMember))) return 2;
+ return 0;
+}
+
+Handle(StepDimTol_DatumReferenceModifierWithValue) StepDimTol_DatumReferenceModifier::
+ DatumReferenceModifierWithValue() const
+{ return GetCasted(StepDimTol_DatumReferenceModifierWithValue,Value()); }
+
+Handle(StepDimTol_SimpleDatumReferenceModifierMember) StepDimTol_DatumReferenceModifier::
+ SimpleDatumReferenceModifierMember() const
+{ return GetCasted(StepDimTol_SimpleDatumReferenceModifierMember,Value()); }
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_DatumReferenceModifier_HeaderFile
+#define _StepDimTol_DatumReferenceModifier_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <Standard_Integer.hxx>
+#include <StepData_SelectType.hxx>
+#include <StepDimTol_DatumReferenceModifierWithValue.hxx>
+#include <StepDimTol_SimpleDatumReferenceModifierMember.hxx>
+
+class Standard_Transient;
+
+class StepDimTol_DatumReferenceModifier : public StepData_SelectType
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ //! Returns a DatumReferenceModifier select type
+ Standard_EXPORT StepDimTol_DatumReferenceModifier();
+
+ //! Recognizes a DatumReferenceModifier Kind Entity that is :
+ //! 1 -> DatumReferenceModifierWithValue
+ //! 2 -> SimpleDatumReferenceModifierMember
+ //! 0 else
+ Standard_EXPORT Standard_Integer CaseNum (const Handle(Standard_Transient)& ent) const;
+
+ //! returns Value as a DatumReferenceModifierWithValue (Null if another type)
+ Standard_EXPORT Handle(StepDimTol_DatumReferenceModifierWithValue) DatumReferenceModifierWithValue() const;
+
+ //! returns Value as a SimpleDatumReferenceModifierMember (Null if another type)
+ Standard_EXPORT Handle(StepDimTol_SimpleDatumReferenceModifierMember) SimpleDatumReferenceModifierMember() const;
+
+};
+#endif // _StepDimTol_DatumReferenceModifier_HeaderFile
--- /dev/null
+// Created on: 2015-07-14
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_DatumReferenceModifierType_HeaderFile
+#define _StepDimTol_DatumReferenceModifierType_HeaderFile
+
+#include <Standard_PrimitiveTypes.hxx>
+
+enum StepDimTol_DatumReferenceModifierType {
+ StepDimTol_CircularOrCylindrical,
+ StepDimTol_Distance,
+ StepDimTol_Projected,
+ StepDimTol_Spherical
+};
+
+#endif
\ No newline at end of file
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepDimTol_DatumReferenceModifierWithValue.hxx>
+
+//=======================================================================
+//function : StepDimTol_DatumReferenceModifierWithValue
+//purpose :
+//=======================================================================
+
+StepDimTol_DatumReferenceModifierWithValue::StepDimTol_DatumReferenceModifierWithValue ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepDimTol_DatumReferenceModifierWithValue::Init (const StepDimTol_DatumReferenceModifierType& theModifierType,
+ const Handle(StepBasic_LengthMeasureWithUnit)& theModifierValue)
+{
+ modifierType = theModifierType;
+ modifierValue = theModifierValue;
+}
+
\ No newline at end of file
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_DatumReferenceModifierWithValue_HeaderFile
+#define _StepDimTol_DatumReferenceModifierWithValue_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineHandle.hxx>
+#include <Standard_Handle.hxx>
+
+#include <MMgt_TShared.hxx>
+#include <Standard_Integer.hxx>
+#include <StepBasic_LengthMeasureWithUnit.hxx>
+#include <StepDimTol_DatumReferenceModifierType.hxx>
+
+class StepDimTol_DatumReferenceModifierWithValue;
+DEFINE_STANDARD_HANDLE(StepDimTol_DatumReferenceModifierWithValue, MMgt_TShared)
+//! Representation of STEP entity DatumReferenceModifierWithValue
+class StepDimTol_DatumReferenceModifierWithValue : public MMgt_TShared
+{
+
+public:
+
+ //! Empty constructor
+ Standard_EXPORT StepDimTol_DatumReferenceModifierWithValue();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init (const StepDimTol_DatumReferenceModifierType& theModifierType,
+ const Handle(StepBasic_LengthMeasureWithUnit)& theModifierValue);
+
+ //! Returns field ModifierType
+ inline StepDimTol_DatumReferenceModifierType ModifierType () const
+ {
+ return modifierType;
+ }
+
+ //! Set field ModifierType
+ inline void SetModifierType (const StepDimTol_DatumReferenceModifierType &theModifierType)
+ {
+ modifierType = theModifierType;
+ }
+
+ //! Returns field ModifierValue
+ inline Handle(StepBasic_LengthMeasureWithUnit) ModifierValue()
+ {
+ return modifierValue;
+ }
+
+ //! Set field ModifierValue
+ inline void SetModifierValue(const Handle(StepBasic_LengthMeasureWithUnit)& theModifierValue)
+ {
+ modifierValue = theModifierValue;
+ }
+
+ DEFINE_STANDARD_RTTI(StepDimTol_DatumReferenceModifierWithValue, MMgt_TShared)
+
+private:
+ StepDimTol_DatumReferenceModifierType modifierType;
+ Handle(StepBasic_LengthMeasureWithUnit) modifierValue;
+};
+#endif // _StepDimTol_DatumReferenceModifierWithValue_HeaderFile
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepDimTol_DatumSystem.hxx>
+
+#include <StepDimTol_HArray1OfDatumReferenceCompartment.hxx>
+
+//=======================================================================
+//function : StepDimTol_DatumSystem
+//purpose :
+//=======================================================================
+
+StepDimTol_DatumSystem::StepDimTol_DatumSystem ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepDimTol_DatumSystem::Init (const Handle(TCollection_HAsciiString)& theName,
+ const Handle(TCollection_HAsciiString)& theDescription,
+ const Handle(StepRepr_ProductDefinitionShape)& theOfShape,
+ const StepData_Logical theProductDefinitional,
+ const Handle(StepDimTol_HArray1OfDatumReferenceCompartment)& theConstituents)
+{
+ StepRepr_ShapeAspect::Init(theName, theDescription, theOfShape, theProductDefinitional);
+ constituents = theConstituents;
+}
+
\ No newline at end of file
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_DatumSystem_HeaderFile
+#define _StepDimTol_DatumSystem_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <Standard_Integer.hxx>
+#include <StepRepr_ShapeAspect.hxx>
+#include <StepDimTol_HArray1OfDatumReferenceCompartment.hxx>
+
+class StepDimTol_DatumSystem;
+DEFINE_STANDARD_HANDLE(StepDimTol_DatumSystem, StepRepr_ShapeAspect)
+//! Representation of STEP entity DatumSystem
+class StepDimTol_DatumSystem : public StepRepr_ShapeAspect
+{
+
+public:
+
+ //! Empty constructor
+ Standard_EXPORT StepDimTol_DatumSystem();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& theName,
+ const Handle(TCollection_HAsciiString)& theDescription,
+ const Handle(StepRepr_ProductDefinitionShape)& theOfShape,
+ const StepData_Logical theProductDefinitional,
+ const Handle(StepDimTol_HArray1OfDatumReferenceCompartment)& theConstituents);
+
+ //! Returns field Constituents
+ inline Handle(StepDimTol_HArray1OfDatumReferenceCompartment) Constituents()
+ {
+ return constituents;
+ }
+
+ //! Set field Constituents
+ inline void SetConstituents(const Handle(StepDimTol_HArray1OfDatumReferenceCompartment)& theConstituents)
+ {
+ constituents = theConstituents;
+ }
+
+ //! Returns number of Constituents
+ inline Standard_Integer NbConstituents () const
+ {
+ return (constituents.IsNull() ? 0 : constituents->Length());
+ }
+
+ //! Returns Constituents with the given number
+ inline Handle(StepDimTol_DatumReferenceCompartment) ConstituentsValue(const Standard_Integer num) const
+ {
+ return constituents->Value(num);
+ }
+
+ //! Sets Constituents with given number
+ inline void ConstituentsValue(const Standard_Integer num, const Handle(StepDimTol_DatumReferenceCompartment)& theItem)
+ {
+ constituents->SetValue (num, theItem);
+ }
+
+ DEFINE_STANDARD_RTTI(StepDimTol_DatumSystem, StepRepr_ShapeAspect)
+
+private:
+ Handle(StepDimTol_HArray1OfDatumReferenceCompartment) constituents;
+};
+#endif // _StepDimTol_DatumSystem_HeaderFile
--- /dev/null
+// Created on: 2015-07-21
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepDimTol_DatumSystemOrReference.hxx>
+#include <Interface_Macros.hxx>
+#include <StepDimTol_DatumSystem.hxx>
+#include <StepDimTol_DatumReference.hxx>
+
+//=======================================================================
+//function : StepDimTol_DatumSystemOrReference
+//purpose :
+//=======================================================================
+
+StepDimTol_DatumSystemOrReference::StepDimTol_DatumSystemOrReference () { }
+
+//=======================================================================
+//function : CaseNum
+//purpose :
+//=======================================================================
+
+Standard_Integer StepDimTol_DatumSystemOrReference::CaseNum(const Handle(Standard_Transient)& ent) const
+{
+ if (ent.IsNull()) return 0;
+ if (ent->IsKind(STANDARD_TYPE(StepDimTol_DatumSystem))) return 1;
+ if (ent->IsKind(STANDARD_TYPE(StepDimTol_DatumReference))) return 2;
+ return 0;
+}
+
+Handle(StepDimTol_DatumSystem) StepDimTol_DatumSystemOrReference::DatumSystem() const
+{ return GetCasted(StepDimTol_DatumSystem,Value()); }
+
+Handle(StepDimTol_DatumReference) StepDimTol_DatumSystemOrReference::DatumReference() const
+{ return GetCasted(StepDimTol_DatumReference,Value()); }
--- /dev/null
+// Created on: 2015-07-21
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_DatumSystemOrReference_HeaderFile
+#define _StepDimTol_DatumSystemOrReference_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <StepData_SelectType.hxx>
+#include <Standard_Integer.hxx>
+
+class Standard_Transient;
+class StepDimTol_DatumSystem;
+class StepDimTol_DatumReference;
+
+class StepDimTol_DatumSystemOrReference : public StepData_SelectType
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ //! Returns a DatumSystemOrReference select type
+ Standard_EXPORT StepDimTol_DatumSystemOrReference();
+
+ //! Recognizes a DatumSystemOrReference Kind Entity that is :
+ //! 1 -> DatumSystem
+ //! 2 -> DatumReference
+ //! 0 else
+ Standard_EXPORT Standard_Integer CaseNum (const Handle(Standard_Transient)& ent) const;
+
+ //! returns Value as a DatumSystem (Null if another type)
+ Standard_EXPORT Handle(StepDimTol_DatumSystem) DatumSystem() const;
+
+ //! returns Value as a DatumReference (Null if another type)
+ Standard_EXPORT Handle(StepDimTol_DatumReference) DatumReference() const;
+};
+#endif // _StepDimTol_DatumSystemOrReference_HeaderFile
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepDimTol_GeneralDatumReference.hxx>
+
+#include <StepDimTol_HArray1OfDatumReferenceModifier.hxx>
+
+//=======================================================================
+//function : StepDimTol_GeneralDatumReference
+//purpose :
+//=======================================================================
+
+StepDimTol_GeneralDatumReference::StepDimTol_GeneralDatumReference ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepDimTol_GeneralDatumReference::Init (const Handle(TCollection_HAsciiString)& theName,
+ const Handle(TCollection_HAsciiString)& theDescription,
+ const Handle(StepRepr_ProductDefinitionShape)& theOfShape,
+ const StepData_Logical theProductDefinitional,
+ const StepDimTol_DatumOrCommonDatum& theBase,
+ const Standard_Boolean hasModifiers,
+ const Handle(StepDimTol_HArray1OfDatumReferenceModifier)& theModifiers)
+{
+ StepRepr_ShapeAspect::Init(theName, theDescription, theOfShape, theProductDefinitional);
+ base = theBase;
+ if (hasModifiers)
+ modifiers = theModifiers;
+ else
+ modifiers.Nullify();
+}
+
\ No newline at end of file
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_GeneralDatumReference_HeaderFile
+#define _StepDimTol_GeneralDatumReference_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <Standard_Integer.hxx>
+#include <StepRepr_ShapeAspect.hxx>
+#include <StepDimTol_DatumOrCommonDatum.hxx>
+#include <StepDimTol_HArray1OfDatumReferenceModifier.hxx>
+
+class StepDimTol_GeneralDatumReference;
+DEFINE_STANDARD_HANDLE(StepDimTol_GeneralDatumReference, StepRepr_ShapeAspect)
+//! Representation of STEP entity GeneralDatumReference
+class StepDimTol_GeneralDatumReference : public StepRepr_ShapeAspect
+{
+
+public:
+
+ //! Empty constructor
+ Standard_EXPORT StepDimTol_GeneralDatumReference();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& theName,
+ const Handle(TCollection_HAsciiString)& theDescription,
+ const Handle(StepRepr_ProductDefinitionShape)& theOfShape,
+ const StepData_Logical theProductDefinitional,
+ const StepDimTol_DatumOrCommonDatum& theBase,
+ const Standard_Boolean hasModifiers,
+ const Handle(StepDimTol_HArray1OfDatumReferenceModifier)& theModifiers);
+
+ //! Returns field Base
+ inline StepDimTol_DatumOrCommonDatum Base()
+ {
+ return base;
+ }
+
+ //! Set field Base
+ inline void SetBase(const StepDimTol_DatumOrCommonDatum& theBase)
+ {
+ base = theBase;
+ }
+
+ //! Indicates is field Modifiers exist
+ inline Standard_Boolean HasModifiers() const
+ {
+ return modifiers.IsNull();
+ }
+
+ //! Returns field Modifiers
+ inline Handle(StepDimTol_HArray1OfDatumReferenceModifier) Modifiers()
+ {
+ return modifiers;
+ }
+
+ //! Set field Modifiers
+ inline void SetModifiers(const Handle(StepDimTol_HArray1OfDatumReferenceModifier)& theModifiers)
+ {
+ modifiers = theModifiers;
+ }
+
+ //! Returns number of Modifiers
+ inline Standard_Integer NbModifiers () const
+ {
+ return (modifiers.IsNull() ? 0 : modifiers->Length());
+ }
+
+ //! Returns Modifiers with the given number
+ inline StepDimTol_DatumReferenceModifier ModifiersValue(const Standard_Integer num) const
+ {
+ return modifiers->Value(num);
+ }
+
+ //! Sets Modifiers with given number
+ inline void ModifiersValue(const Standard_Integer num, const StepDimTol_DatumReferenceModifier& theItem)
+ {
+ modifiers->SetValue (num, theItem);
+ }
+
+ DEFINE_STANDARD_RTTI(StepDimTol_GeneralDatumReference, StepRepr_ShapeAspect)
+
+private:
+ StepDimTol_DatumOrCommonDatum base;
+ Handle(StepDimTol_HArray1OfDatumReferenceModifier) modifiers;
+};
+#endif // _StepDimTol_GeneralDatumReference_HeaderFile
--- /dev/null
+// Created on: 2015-08-10
+// Created by: Irina KRYLOVA
+// 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.
+
+
+#include <Standard_Type.hxx>
+#include <StepBasic_MeasureWithUnit.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
+#include <StepDimTol_GeometricToleranceWithDatumReference.hxx>
+#include <StepDimTol_GeoTolAndGeoTolWthDatRef.hxx>
+#include <StepRepr_ShapeAspect.hxx>
+#include <TCollection_HAsciiString.hxx>
+
+//=======================================================================
+//function : StepDimTol_GeoTolAndGeoTolWthDatRef
+//purpose :
+//=======================================================================
+StepDimTol_GeoTolAndGeoTolWthDatRef::StepDimTol_GeoTolAndGeoTolWthDatRef()
+{
+}
+
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepDimTol_GeoTolAndGeoTolWthDatRef::Init
+ (const Handle(TCollection_HAsciiString)& theName,
+ const Handle(TCollection_HAsciiString)& theDescription,
+ const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
+ const Handle(StepDimTol_GeometricToleranceWithDatumReference)& theGTWDR,
+ const StepDimTol_GeometricToleranceType theType)
+{
+ SetName(theName);
+ SetDescription(theDescription);
+ SetMagnitude(theMagnitude);
+ SetTolerancedShapeAspect(theTolerancedShapeAspect);
+ myGeometricToleranceWithDatumReference = theGTWDR;
+ myToleranceType = theType;
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepDimTol_GeoTolAndGeoTolWthDatRef::Init
+ (const Handle(TCollection_HAsciiString)& theName,
+ const Handle(TCollection_HAsciiString)& theDescription,
+ const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const StepDimTol_GeometricToleranceTarget& theTolerancedShapeAspect,
+ const Handle(StepDimTol_GeometricToleranceWithDatumReference)& theGTWDR,
+ const StepDimTol_GeometricToleranceType theType)
+{
+ SetName(theName);
+ SetDescription(theDescription);
+ SetMagnitude(theMagnitude);
+ SetTolerancedShapeAspect(theTolerancedShapeAspect);
+ myGeometricToleranceWithDatumReference = theGTWDR;
+ myToleranceType = theType;
+}
--- /dev/null
+// Created on: 2015-08-10
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_GeoTolAndGeoTolWthDatRef_HeaderFile
+#define _StepDimTol_GeoTolAndGeoTolWthDatRef_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepDimTol_GeometricTolerance.hxx>
+#include <StepDimTol_GeometricToleranceType.hxx>
+class StepDimTol_GeometricToleranceTarget;
+class StepDimTol_GeometricToleranceWithDatumReference;
+class TCollection_HAsciiString;
+class StepBasic_MeasureWithUnit;
+class StepRepr_ShapeAspect;
+
+
+class StepDimTol_GeoTolAndGeoTolWthDatRef;
+DEFINE_STANDARD_HANDLE(StepDimTol_GeoTolAndGeoTolWthDatRef, StepDimTol_GeometricTolerance)
+
+class StepDimTol_GeoTolAndGeoTolWthDatRef : public StepDimTol_GeometricTolerance
+{
+
+public:
+
+
+ Standard_EXPORT StepDimTol_GeoTolAndGeoTolWthDatRef();
+
+ Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& theName,
+ const Handle(TCollection_HAsciiString)& theDescription,
+ const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
+ const Handle(StepDimTol_GeometricToleranceWithDatumReference)& theGTWDR,
+ const StepDimTol_GeometricToleranceType theType);
+
+ Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& aName,
+ const Handle(TCollection_HAsciiString)& aDescription,
+ const Handle(StepBasic_MeasureWithUnit)& aMagnitude,
+ const StepDimTol_GeometricToleranceTarget& aTolerancedShapeAspect,
+ const Handle(StepDimTol_GeometricToleranceWithDatumReference)& aGTWDR,
+ const StepDimTol_GeometricToleranceType theType);
+
+ inline void SetGeometricToleranceWithDatumReference (const Handle(StepDimTol_GeometricToleranceWithDatumReference)& theGTWDR){
+ myGeometricToleranceWithDatumReference = theGTWDR;
+ }
+
+ inline Handle(StepDimTol_GeometricToleranceWithDatumReference) GetGeometricToleranceWithDatumReference() const {
+ return myGeometricToleranceWithDatumReference;
+ }
+
+ inline void SetGeometricToleranceType (const StepDimTol_GeometricToleranceType theType){
+ myToleranceType = theType;
+ }
+
+ Standard_EXPORT StepDimTol_GeometricToleranceType GetToleranceType() const {
+ return myToleranceType;
+ }
+
+ DEFINE_STANDARD_RTTI(StepDimTol_GeoTolAndGeoTolWthDatRef,StepDimTol_GeometricTolerance)
+
+private:
+
+ Handle(StepDimTol_GeometricToleranceWithDatumReference) myGeometricToleranceWithDatumReference;
+ StepDimTol_GeometricToleranceType myToleranceType;
+};
+#endif // _StepDimTol_GeoTolAndGeoTolWthDatRef_HeaderFile
--- /dev/null
+// Created on: 2015-08-06
+// Created by: Irina KRYLOVA
+// 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.
+
+
+#include <Standard_Type.hxx>
+#include <StepBasic_MeasureWithUnit.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
+#include <StepDimTol_GeometricToleranceWithDatumReference.hxx>
+#include <StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod.hxx>
+#include <StepDimTol_GeometricToleranceWithModifiers.hxx>
+#include <StepRepr_ShapeAspect.hxx>
+#include <TCollection_HAsciiString.hxx>
+
+//=======================================================================
+//function : StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod
+//purpose :
+//=======================================================================
+StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod::StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod()
+{
+}
+
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod::Init
+ (const Handle(TCollection_HAsciiString)& theName,
+ const Handle(TCollection_HAsciiString)& theDescription,
+ const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
+ const Handle(StepDimTol_GeometricToleranceWithDatumReference)& theGTWDR,
+ const Handle(StepDimTol_GeometricToleranceWithModifiers)& theGTWM,
+ const StepDimTol_GeometricToleranceType theType)
+{
+ SetName(theName);
+ SetDescription(theDescription);
+ SetMagnitude(theMagnitude);
+ SetTolerancedShapeAspect(theTolerancedShapeAspect);
+ myGeometricToleranceWithDatumReference = theGTWDR;
+ myGeometricToleranceWithModifiers = theGTWM;
+ myToleranceType = theType;
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod::Init
+ (const Handle(TCollection_HAsciiString)& theName,
+ const Handle(TCollection_HAsciiString)& theDescription,
+ const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const StepDimTol_GeometricToleranceTarget& theTolerancedShapeAspect,
+ const Handle(StepDimTol_GeometricToleranceWithDatumReference)& theGTWDR,
+ const Handle(StepDimTol_GeometricToleranceWithModifiers)& theGTWM,
+ const StepDimTol_GeometricToleranceType theType)
+{
+ SetName(theName);
+ SetDescription(theDescription);
+ SetMagnitude(theMagnitude);
+ SetTolerancedShapeAspect(theTolerancedShapeAspect);
+ myGeometricToleranceWithDatumReference = theGTWDR;
+ myGeometricToleranceWithModifiers = theGTWM;
+ myToleranceType = theType;
+}
--- /dev/null
+// Created on: 2015-08-06
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod_HeaderFile
+#define _StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepDimTol_GeometricTolerance.hxx>
+#include <StepDimTol_GeometricToleranceType.hxx>
+class StepDimTol_GeometricToleranceTarget;
+class StepDimTol_GeometricToleranceWithDatumReference;
+class StepDimTol_GeometricToleranceWithModifiers;
+class TCollection_HAsciiString;
+class StepBasic_MeasureWithUnit;
+class StepRepr_ShapeAspect;
+
+
+class StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod;
+DEFINE_STANDARD_HANDLE(StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod, StepDimTol_GeometricTolerance)
+
+class StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod : public StepDimTol_GeometricTolerance
+{
+
+public:
+
+
+ Standard_EXPORT StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod();
+
+ Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& theName,
+ const Handle(TCollection_HAsciiString)& theDescription,
+ const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
+ const Handle(StepDimTol_GeometricToleranceWithDatumReference)& theGTWDR,
+ const Handle(StepDimTol_GeometricToleranceWithModifiers)& theGTWM,
+ const StepDimTol_GeometricToleranceType theType);
+
+ Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& aName,
+ const Handle(TCollection_HAsciiString)& aDescription,
+ const Handle(StepBasic_MeasureWithUnit)& aMagnitude,
+ const StepDimTol_GeometricToleranceTarget& aTolerancedShapeAspect,
+ const Handle(StepDimTol_GeometricToleranceWithDatumReference)& aGTWDR,
+ const Handle(StepDimTol_GeometricToleranceWithModifiers)& aGTWM,
+ const StepDimTol_GeometricToleranceType theType);
+
+ inline void SetGeometricToleranceWithDatumReference (const Handle(StepDimTol_GeometricToleranceWithDatumReference)& theGTWDR){
+ myGeometricToleranceWithDatumReference = theGTWDR;
+ }
+
+ inline Handle(StepDimTol_GeometricToleranceWithDatumReference) GetGeometricToleranceWithDatumReference() const {
+ return myGeometricToleranceWithDatumReference;
+ }
+
+ inline void SetGeometricToleranceWithModifiers (const Handle(StepDimTol_GeometricToleranceWithModifiers)& theGTWM) {
+ myGeometricToleranceWithModifiers = theGTWM;
+ }
+
+ inline Handle(StepDimTol_GeometricToleranceWithModifiers) GetGeometricToleranceWithModifiers() const {
+ return myGeometricToleranceWithModifiers;
+ }
+
+ inline void SetGeometricToleranceType (const StepDimTol_GeometricToleranceType theType){
+ myToleranceType = theType;
+ }
+
+ Standard_EXPORT StepDimTol_GeometricToleranceType GetToleranceType() const {
+ return myToleranceType;
+ }
+
+ DEFINE_STANDARD_RTTI(StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod,StepDimTol_GeometricTolerance)
+
+private:
+
+ Handle(StepDimTol_GeometricToleranceWithDatumReference) myGeometricToleranceWithDatumReference;
+ Handle(StepDimTol_GeometricToleranceWithModifiers) myGeometricToleranceWithModifiers;
+ StepDimTol_GeometricToleranceType myToleranceType;
+};
+#endif // _StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod_HeaderFile
#include <Standard_Type.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
#include <StepDimTol_GeometricToleranceWithDatumReference.hxx>
#include <StepDimTol_GeoTolAndGeoTolWthDatRefAndModGeoTolAndPosTol.hxx>
#include <StepDimTol_ModifiedGeometricTolerance.hxx>
myModifiedGeometricTolerance = aMGT;
}
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepDimTol_GeoTolAndGeoTolWthDatRefAndModGeoTolAndPosTol::Init
+ (const Handle(TCollection_HAsciiString)& aName,
+ const Handle(TCollection_HAsciiString)& aDescription,
+ const Handle(StepBasic_MeasureWithUnit)& aMagnitude,
+ const StepDimTol_GeometricToleranceTarget& aTolerancedShapeAspect,
+ const Handle(StepDimTol_GeometricToleranceWithDatumReference)& aGTWDR,
+ const Handle(StepDimTol_ModifiedGeometricTolerance)& aMGT)
+{
+ SetName(aName);
+ SetDescription(aDescription);
+ SetMagnitude(aMagnitude);
+ SetTolerancedShapeAspect(aTolerancedShapeAspect);
+ myGeometricToleranceWithDatumReference = aGTWDR;
+ myModifiedGeometricTolerance = aMGT;
+}
+
//=======================================================================
//function : SetGeometricToleranceWithDatumReference
#include <Standard_Type.hxx>
#include <StepDimTol_GeometricTolerance.hxx>
+class StepDimTol_GeometricToleranceTarget;
class StepDimTol_GeometricToleranceWithDatumReference;
class StepDimTol_ModifiedGeometricTolerance;
class StepDimTol_PositionTolerance;
Standard_EXPORT StepDimTol_GeoTolAndGeoTolWthDatRefAndModGeoTolAndPosTol();
Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& aName, const Handle(TCollection_HAsciiString)& aDescription, const Handle(StepBasic_MeasureWithUnit)& aMagnitude, const Handle(StepRepr_ShapeAspect)& aTolerancedShapeAspect, const Handle(StepDimTol_GeometricToleranceWithDatumReference)& aGTWDR, const Handle(StepDimTol_ModifiedGeometricTolerance)& aMGT);
-
+
+ Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& aName, const Handle(TCollection_HAsciiString)& aDescription, const Handle(StepBasic_MeasureWithUnit)& aMagnitude, const StepDimTol_GeometricToleranceTarget& aTolerancedShapeAspect, const Handle(StepDimTol_GeometricToleranceWithDatumReference)& aGTWDR, const Handle(StepDimTol_ModifiedGeometricTolerance)& aMGT);
+
Standard_EXPORT void SetGeometricToleranceWithDatumReference (const Handle(StepDimTol_GeometricToleranceWithDatumReference)& aGTWDR);
Standard_EXPORT Handle(StepDimTol_GeometricToleranceWithDatumReference) GetGeometricToleranceWithDatumReference() const;
--- /dev/null
+// Created on: 2015-08-11
+// Created by: Irina KRYLOVA
+// 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.
+
+
+#include <Standard_Type.hxx>
+#include <StepBasic_MeasureWithUnit.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
+#include <StepDimTol_GeometricToleranceWithDatumReference.hxx>
+#include <StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol.hxx>
+#include <StepDimTol_UnequallyDisposedGeometricTolerance.hxx>
+#include <StepRepr_ShapeAspect.hxx>
+#include <TCollection_HAsciiString.hxx>
+
+//=======================================================================
+//function : StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol
+//purpose :
+//=======================================================================
+StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol::StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol()
+{
+}
+
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol::Init
+ (const Handle(TCollection_HAsciiString)& theName,
+ const Handle(TCollection_HAsciiString)& theDescription,
+ const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
+ const Handle(StepDimTol_GeometricToleranceWithDatumReference)& theGTWDR,
+ const StepDimTol_GeometricToleranceType theType,
+ const Handle(StepDimTol_UnequallyDisposedGeometricTolerance)& theUDGT)
+{
+ StepDimTol_GeoTolAndGeoTolWthDatRef::Init(theName, theDescription, theMagnitude,
+ theTolerancedShapeAspect, theGTWDR, theType);
+ myUnequallyDisposedGeometricTolerance = theUDGT;
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol::Init
+ (const Handle(TCollection_HAsciiString)& theName,
+ const Handle(TCollection_HAsciiString)& theDescription,
+ const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const StepDimTol_GeometricToleranceTarget& theTolerancedShapeAspect,
+ const Handle(StepDimTol_GeometricToleranceWithDatumReference)& theGTWDR,
+ const StepDimTol_GeometricToleranceType theType,
+ const Handle(StepDimTol_UnequallyDisposedGeometricTolerance)& theUDGT)
+{
+ StepDimTol_GeoTolAndGeoTolWthDatRef::Init(theName, theDescription, theMagnitude,
+ theTolerancedShapeAspect, theGTWDR, theType);
+ myUnequallyDisposedGeometricTolerance = theUDGT;
+}
--- /dev/null
+// Created on: 2015-08-11
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol_HeaderFile
+#define _StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepDimTol_GeoTolAndGeoTolWthDatRef.hxx>
+class StepDimTol_GeometricToleranceTarget;
+class StepDimTol_GeometricToleranceWithDatumReference;
+class StepDimTol_UnequallyDisposedGeometricTolerance;
+class TCollection_HAsciiString;
+class StepBasic_MeasureWithUnit;
+class StepRepr_ShapeAspect;
+
+
+class StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol;
+DEFINE_STANDARD_HANDLE(StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol, StepDimTol_GeoTolAndGeoTolWthDatRef)
+
+class StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol : public StepDimTol_GeoTolAndGeoTolWthDatRef
+{
+
+public:
+
+
+ Standard_EXPORT StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol();
+
+ Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& theName,
+ const Handle(TCollection_HAsciiString)& theDescription,
+ const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
+ const Handle(StepDimTol_GeometricToleranceWithDatumReference)& theGTWDR,
+ const StepDimTol_GeometricToleranceType theType,
+ const Handle(StepDimTol_UnequallyDisposedGeometricTolerance)& theUDGT);
+
+ Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& aName,
+ const Handle(TCollection_HAsciiString)& aDescription,
+ const Handle(StepBasic_MeasureWithUnit)& aMagnitude,
+ const StepDimTol_GeometricToleranceTarget& aTolerancedShapeAspect,
+ const Handle(StepDimTol_GeometricToleranceWithDatumReference)& aGTWDR,
+ const StepDimTol_GeometricToleranceType theType,
+ const Handle(StepDimTol_UnequallyDisposedGeometricTolerance)& theUDGT);
+
+ inline void SetUnequallyDisposedGeometricTolerance (const Handle(StepDimTol_UnequallyDisposedGeometricTolerance)& theUDGT){
+ myUnequallyDisposedGeometricTolerance = theUDGT;
+ }
+
+ inline Handle(StepDimTol_UnequallyDisposedGeometricTolerance) GetUnequallyDisposedGeometricTolerance() const {
+ return myUnequallyDisposedGeometricTolerance;
+ }
+
+ DEFINE_STANDARD_RTTI(StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol,StepDimTol_GeoTolAndGeoTolWthDatRef)
+
+private:
+
+ Handle(StepDimTol_UnequallyDisposedGeometricTolerance) myUnequallyDisposedGeometricTolerance;
+};
+#endif // _StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol_HeaderFile
--- /dev/null
+// Created on: 2015-08-10
+// Created by: Irina KRYLOVA
+// 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.
+
+
+#include <Standard_Type.hxx>
+#include <StepBasic_MeasureWithUnit.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
+#include <StepDimTol_GeoTolAndGeoTolWthMod.hxx>
+#include <StepDimTol_GeometricToleranceWithModifiers.hxx>
+#include <StepRepr_ShapeAspect.hxx>
+#include <TCollection_HAsciiString.hxx>
+
+//=======================================================================
+//function : StepDimTol_GeoTolAndGeoTolWthMod
+//purpose :
+//=======================================================================
+StepDimTol_GeoTolAndGeoTolWthMod::StepDimTol_GeoTolAndGeoTolWthMod()
+{
+}
+
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepDimTol_GeoTolAndGeoTolWthMod::Init
+ (const Handle(TCollection_HAsciiString)& theName,
+ const Handle(TCollection_HAsciiString)& theDescription,
+ const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
+ const Handle(StepDimTol_GeometricToleranceWithModifiers)& theGTWM,
+ const StepDimTol_GeometricToleranceType theType)
+{
+ SetName(theName);
+ SetDescription(theDescription);
+ SetMagnitude(theMagnitude);
+ SetTolerancedShapeAspect(theTolerancedShapeAspect);
+ myGeometricToleranceWithModifiers = theGTWM;
+ myToleranceType = theType;
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepDimTol_GeoTolAndGeoTolWthMod::Init
+ (const Handle(TCollection_HAsciiString)& theName,
+ const Handle(TCollection_HAsciiString)& theDescription,
+ const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const StepDimTol_GeometricToleranceTarget& theTolerancedShapeAspect,
+ const Handle(StepDimTol_GeometricToleranceWithModifiers)& theGTWM,
+ const StepDimTol_GeometricToleranceType theType)
+{
+ SetName(theName);
+ SetDescription(theDescription);
+ SetMagnitude(theMagnitude);
+ SetTolerancedShapeAspect(theTolerancedShapeAspect);
+ myGeometricToleranceWithModifiers = theGTWM;
+ myToleranceType = theType;
+}
--- /dev/null
+// Created on: 2015-08-10
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_GeoTolAndGeoTolWthMod_HeaderFile
+#define _StepDimTol_GeoTolAndGeoTolWthMod_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepDimTol_GeometricTolerance.hxx>
+#include <StepDimTol_GeometricToleranceType.hxx>
+class StepDimTol_GeometricToleranceTarget;
+class StepDimTol_GeometricToleranceWithModifiers;
+class TCollection_HAsciiString;
+class StepBasic_MeasureWithUnit;
+class StepRepr_ShapeAspect;
+
+
+class StepDimTol_GeoTolAndGeoTolWthMod;
+DEFINE_STANDARD_HANDLE(StepDimTol_GeoTolAndGeoTolWthMod, StepDimTol_GeometricTolerance)
+
+class StepDimTol_GeoTolAndGeoTolWthMod : public StepDimTol_GeometricTolerance
+{
+
+public:
+
+
+ Standard_EXPORT StepDimTol_GeoTolAndGeoTolWthMod();
+
+ Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& theName,
+ const Handle(TCollection_HAsciiString)& theDescription,
+ const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
+ const Handle(StepDimTol_GeometricToleranceWithModifiers)& theGTWM,
+ const StepDimTol_GeometricToleranceType theType);
+
+ Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& aName,
+ const Handle(TCollection_HAsciiString)& aDescription,
+ const Handle(StepBasic_MeasureWithUnit)& aMagnitude,
+ const StepDimTol_GeometricToleranceTarget& aTolerancedShapeAspect,
+ const Handle(StepDimTol_GeometricToleranceWithModifiers)& aGTWM,
+ const StepDimTol_GeometricToleranceType theType);
+
+ inline void SetGeometricToleranceWithModifiers (const Handle(StepDimTol_GeometricToleranceWithModifiers)& theGTWM) {
+ myGeometricToleranceWithModifiers = theGTWM;
+ }
+
+ inline Handle(StepDimTol_GeometricToleranceWithModifiers) GetGeometricToleranceWithModifiers() const {
+ return myGeometricToleranceWithModifiers;
+ }
+
+ inline void SetGeometricToleranceType (const StepDimTol_GeometricToleranceType theType){
+ myToleranceType = theType;
+ }
+
+ Standard_EXPORT StepDimTol_GeometricToleranceType GetToleranceType() const {
+ return myToleranceType;
+ }
+
+ DEFINE_STANDARD_RTTI(StepDimTol_GeoTolAndGeoTolWthMod,StepDimTol_GeometricTolerance)
+
+private:
+
+ Handle(StepDimTol_GeometricToleranceWithModifiers) myGeometricToleranceWithModifiers;
+ StepDimTol_GeometricToleranceType myToleranceType;
+};
+#endif // _StepDimTol_GeoTolAndGeoTolWthMod_HeaderFile
#include <Standard_Type.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepDimTol_GeometricTolerance.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
#include <StepRepr_ShapeAspect.hxx>
#include <TCollection_HAsciiString.hxx>
void StepDimTol_GeometricTolerance::Init (const Handle(TCollection_HAsciiString) &aName,
const Handle(TCollection_HAsciiString) &aDescription,
const Handle(StepBasic_MeasureWithUnit) &aMagnitude,
- const Handle(StepRepr_ShapeAspect) &aTolerancedShapeAspect)
+ const StepDimTol_GeometricToleranceTarget &aTolerancedShapeAspect)
{
theName = aName;
theTolerancedShapeAspect = aTolerancedShapeAspect;
}
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepDimTol_GeometricTolerance::Init (const Handle(TCollection_HAsciiString) &aName,
+ const Handle(TCollection_HAsciiString) &aDescription,
+ const Handle(StepBasic_MeasureWithUnit) &aMagnitude,
+ const Handle(StepRepr_ShapeAspect) &aTolerancedShapeAspect)
+{
+
+ theName = aName;
+
+ theDescription = aDescription;
+
+ theMagnitude = aMagnitude;
+
+ theTolerancedShapeAspect.SetValue(aTolerancedShapeAspect);
+}
+
//=======================================================================
//function : Name
//purpose :
//purpose :
//=======================================================================
-Handle(StepRepr_ShapeAspect) StepDimTol_GeometricTolerance::TolerancedShapeAspect () const
+StepDimTol_GeometricToleranceTarget StepDimTol_GeometricTolerance::TolerancedShapeAspect () const
{
return theTolerancedShapeAspect;
}
//=======================================================================
void StepDimTol_GeometricTolerance::SetTolerancedShapeAspect (const Handle(StepRepr_ShapeAspect) &aTolerancedShapeAspect)
+{
+ theTolerancedShapeAspect.SetValue(aTolerancedShapeAspect);
+}
+
+//=======================================================================
+//function : SetTolerancedShapeAspect
+//purpose :
+//=======================================================================
+
+void StepDimTol_GeometricTolerance::SetTolerancedShapeAspect (const StepDimTol_GeometricToleranceTarget &aTolerancedShapeAspect)
{
theTolerancedShapeAspect = aTolerancedShapeAspect;
}
#include <Standard_Type.hxx>
#include <MMgt_TShared.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
class TCollection_HAsciiString;
class StepBasic_MeasureWithUnit;
+class StepDimTol_GeometricToleranceTarget;
class StepRepr_ShapeAspect;
//! Empty constructor
Standard_EXPORT StepDimTol_GeometricTolerance();
- //! Initialize all fields (own and inherited)
+ //! Initialize all fields (own and inherited) AP214
Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& aName, const Handle(TCollection_HAsciiString)& aDescription, const Handle(StepBasic_MeasureWithUnit)& aMagnitude, const Handle(StepRepr_ShapeAspect)& aTolerancedShapeAspect);
+
+ //! Initialize all fields (own and inherited) AP242
+ Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& aName, const Handle(TCollection_HAsciiString)& aDescription, const Handle(StepBasic_MeasureWithUnit)& aMagnitude, const StepDimTol_GeometricToleranceTarget& aTolerancedShapeAspect);
//! Returns field Name
Standard_EXPORT Handle(TCollection_HAsciiString) Name() const;
Standard_EXPORT void SetMagnitude (const Handle(StepBasic_MeasureWithUnit)& Magnitude);
//! Returns field TolerancedShapeAspect
- Standard_EXPORT Handle(StepRepr_ShapeAspect) TolerancedShapeAspect() const;
+ //! Note: in AP214(203) type of this attribute can be only StepRepr_ShapeAspect
+ Standard_EXPORT StepDimTol_GeometricToleranceTarget TolerancedShapeAspect() const;
- //! Set field TolerancedShapeAspect
+ //! Set field TolerancedShapeAspect AP214
Standard_EXPORT void SetTolerancedShapeAspect (const Handle(StepRepr_ShapeAspect)& TolerancedShapeAspect);
+ //! Set field TolerancedShapeAspect AP242
+ Standard_EXPORT void SetTolerancedShapeAspect (const StepDimTol_GeometricToleranceTarget& TolerancedShapeAspect);
+
Handle(TCollection_HAsciiString) theName;
Handle(TCollection_HAsciiString) theDescription;
Handle(StepBasic_MeasureWithUnit) theMagnitude;
- Handle(StepRepr_ShapeAspect) theTolerancedShapeAspect;
+ StepDimTol_GeometricToleranceTarget theTolerancedShapeAspect;
};
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_GeometricToleranceModifier_HeaderFile
+#define _StepDimTol_GeometricToleranceModifier_HeaderFile
+
+#include <Standard_PrimitiveTypes.hxx>
+
+enum StepDimTol_GeometricToleranceModifier {
+ StepDimTol_GTMAnyCrossSection,
+ StepDimTol_GTMCommonZone,
+ StepDimTol_GTMEachRadialElement,
+ StepDimTol_GTMFreeState,
+ StepDimTol_GTMLeastMaterialRequirement,
+ StepDimTol_GTMLineElement,
+ StepDimTol_GTMMajorDiameter,
+ StepDimTol_GTMMaximumMaterialRequirement,
+ StepDimTol_GTMMinorDiameter,
+ StepDimTol_GTMNotConvex,
+ StepDimTol_GTMPitchDiameter,
+ StepDimTol_GTMReciprocityRequirement,
+ StepDimTol_GTMSeparateRequirement,
+ StepDimTol_GTMStatisticalTolerance,
+ StepDimTol_GTMTangentPlane
+};
+
+#endif
--- /dev/null
+// Created on: 2015-07-20
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepDimTol_GeometricToleranceTarget.hxx>
+#include <Interface_Macros.hxx>
+#include <StepShape_DimensionalLocation.hxx>
+#include <StepShape_DimensionalSize.hxx>
+#include <StepRepr_ProductDefinitionShape.hxx>
+#include <StepRepr_ShapeAspect.hxx>
+
+//=======================================================================
+//function : StepDimTol_GeometricToleranceTarget
+//purpose :
+//=======================================================================
+
+StepDimTol_GeometricToleranceTarget::StepDimTol_GeometricToleranceTarget () { }
+
+//=======================================================================
+//function : CaseNum
+//purpose :
+//=======================================================================
+
+Standard_Integer StepDimTol_GeometricToleranceTarget::CaseNum(const Handle(Standard_Transient)& ent) const
+{
+ if (ent.IsNull()) return 0;
+ if (ent->IsKind(STANDARD_TYPE(StepShape_DimensionalLocation))) return 1;
+ if (ent->IsKind(STANDARD_TYPE(StepShape_DimensionalSize))) return 2;
+ if (ent->IsKind(STANDARD_TYPE(StepRepr_ProductDefinitionShape))) return 3;
+ if (ent->IsKind(STANDARD_TYPE(StepRepr_ShapeAspect))) return 4;
+ return 0;
+}
+
+Handle(StepShape_DimensionalLocation) StepDimTol_GeometricToleranceTarget::DimensionalLocation() const
+{ return GetCasted(StepShape_DimensionalLocation,Value()); }
+
+Handle(StepShape_DimensionalSize) StepDimTol_GeometricToleranceTarget::DimensionalSize() const
+{ return GetCasted(StepShape_DimensionalSize,Value()); }
+
+Handle(StepRepr_ProductDefinitionShape) StepDimTol_GeometricToleranceTarget::ProductDefinitionShape() const
+{ return GetCasted(StepRepr_ProductDefinitionShape,Value()); }
+
+Handle(StepRepr_ShapeAspect) StepDimTol_GeometricToleranceTarget::ShapeAspect() const
+{ return GetCasted(StepRepr_ShapeAspect,Value()); }
--- /dev/null
+// Created on: 2015-07-20
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_GeometricToleranceTarget_HeaderFile
+#define _StepDimTol_GeometricToleranceTarget_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <StepData_SelectType.hxx>
+#include <Standard_Integer.hxx>
+
+class Standard_Transient;
+class StepShape_DimensionalLocation;
+class StepShape_DimensionalSize;
+class StepRepr_ProductDefinitionShape;
+class StepRepr_ShapeAspect;
+
+class StepDimTol_GeometricToleranceTarget : public StepData_SelectType
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ //! Returns a GeometricToleranceTarget select type
+ Standard_EXPORT StepDimTol_GeometricToleranceTarget();
+
+ //! Recognizes a GeometricToleranceTarget Kind Entity that is :
+ //! 1 -> DimensionalLocation
+ //! 2 -> DimensionalSize
+ //! 3 -> ProductDefinitionShape
+ //! 4 -> ShapeAspect
+ //! 0 else
+ Standard_EXPORT Standard_Integer CaseNum (const Handle(Standard_Transient)& ent) const;
+
+ //! returns Value as a DimensionalLocation (Null if another type)
+ Standard_EXPORT Handle(StepShape_DimensionalLocation) DimensionalLocation() const;
+
+ //! returns Value as a DimensionalSize (Null if another type)
+ Standard_EXPORT Handle(StepShape_DimensionalSize) DimensionalSize() const;
+
+ //! returns Value as a ProductDefinitionShape (Null if another type)
+ Standard_EXPORT Handle(StepRepr_ProductDefinitionShape) ProductDefinitionShape() const;
+
+ //! returns Value as a ShapeAspect (Null if another type)
+ Standard_EXPORT Handle(StepRepr_ShapeAspect) ShapeAspect() const;
+};
+#endif // _StepDimTol_GeometricToleranceTarget_HeaderFile
--- /dev/null
+// Created on: 2015-08-10
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_GeometricToleranceType_HeaderFile
+#define _StepDimTol_GeometricToleranceType_HeaderFile
+
+enum StepDimTol_GeometricToleranceType {
+ StepDimTol_GTTAngularityTolerance,
+ StepDimTol_GTTCircularRunoutTolerance,
+ StepDimTol_GTTCoaxialityTolerance,
+ StepDimTol_GTTConcentricityTolerance,
+ StepDimTol_GTTCylindricityTolerance,
+ StepDimTol_GTTFlatnessTolerance,
+ StepDimTol_GTTLineProfileTolerance,
+ StepDimTol_GTTParallelismTolerance,
+ StepDimTol_GTTPerpendicularityTolerance,
+ StepDimTol_GTTPositionTolerance,
+ StepDimTol_GTTRoundnessTolerance,
+ StepDimTol_GTTStraightnessTolerance,
+ StepDimTol_GTTSurfaceProfileTolerance,
+ StepDimTol_GTTSymmetryTolerance,
+ StepDimTol_GTTTotalRunoutTolerance
+};
+
+#endif // _StepDimTol_GeometricToleranceType_HeaderFile
\ No newline at end of file
#include <Standard_Type.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
#include <StepDimTol_GeometricToleranceWithDatumReference.hxx>
#include <StepRepr_ShapeAspect.hxx>
#include <TCollection_HAsciiString.hxx>
aGeometricTolerance_Magnitude,
aGeometricTolerance_TolerancedShapeAspect);
+ theDatumSystem = new StepDimTol_HArray1OfDatumSystemOrReference(aDatumSystem->Lower(), aDatumSystem->Upper());
+ StepDimTol_DatumSystemOrReference anAux;
+ for (Standard_Integer i = aDatumSystem->Lower(); i <= aDatumSystem->Upper(); i++) {
+ anAux.SetValue(aDatumSystem->Value(i));
+ theDatumSystem->SetValue(i, anAux);
+ }
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepDimTol_GeometricToleranceWithDatumReference::Init (const Handle(TCollection_HAsciiString) &aGeometricTolerance_Name,
+ const Handle(TCollection_HAsciiString) &aGeometricTolerance_Description,
+ const Handle(StepBasic_MeasureWithUnit) &aGeometricTolerance_Magnitude,
+ const StepDimTol_GeometricToleranceTarget &aGeometricTolerance_TolerancedShapeAspect,
+ const Handle(StepDimTol_HArray1OfDatumSystemOrReference) &aDatumSystem)
+{
+ StepDimTol_GeometricTolerance::Init(aGeometricTolerance_Name,
+ aGeometricTolerance_Description,
+ aGeometricTolerance_Magnitude,
+ aGeometricTolerance_TolerancedShapeAspect);
+
theDatumSystem = aDatumSystem;
}
//=======================================================================
Handle(StepDimTol_HArray1OfDatumReference) StepDimTol_GeometricToleranceWithDatumReference::DatumSystem () const
+{
+ Handle(StepDimTol_HArray1OfDatumReference) aDatumSystem;
+ aDatumSystem = new StepDimTol_HArray1OfDatumReference(theDatumSystem->Lower(), theDatumSystem->Upper());
+ for (Standard_Integer i = aDatumSystem->Lower(); i <= aDatumSystem->Upper(); i++) {
+ aDatumSystem->SetValue(i, theDatumSystem->Value(i).DatumReference());
+ }
+ return aDatumSystem;
+}
+
+//=======================================================================
+//function : DatumSystemAP242
+//purpose :
+//=======================================================================
+
+Handle(StepDimTol_HArray1OfDatumSystemOrReference) StepDimTol_GeometricToleranceWithDatumReference::DatumSystemAP242 () const
{
return theDatumSystem;
}
//=======================================================================
void StepDimTol_GeometricToleranceWithDatumReference::SetDatumSystem (const Handle(StepDimTol_HArray1OfDatumReference) &aDatumSystem)
+{
+ theDatumSystem = new StepDimTol_HArray1OfDatumSystemOrReference(aDatumSystem->Lower(), aDatumSystem->Upper());
+ StepDimTol_DatumSystemOrReference anAux;
+ for (Standard_Integer i = aDatumSystem->Lower(); i <= aDatumSystem->Upper(); i++) {
+ anAux.SetValue(aDatumSystem->Value(i));
+ theDatumSystem->SetValue(i, anAux);
+ }
+}
+
+//=======================================================================
+//function : SetDatumSystem
+//purpose :
+//=======================================================================
+
+void StepDimTol_GeometricToleranceWithDatumReference::SetDatumSystem (const Handle(StepDimTol_HArray1OfDatumSystemOrReference) &aDatumSystem)
{
theDatumSystem = aDatumSystem;
}
#include <Standard_Type.hxx>
#include <StepDimTol_HArray1OfDatumReference.hxx>
+#include <StepDimTol_HArray1OfDatumSystemOrReference.hxx>
#include <StepDimTol_GeometricTolerance.hxx>
class TCollection_HAsciiString;
class StepBasic_MeasureWithUnit;
+class StepDimTol_GeometricToleranceTarget;
class StepRepr_ShapeAspect;
//! Empty constructor
Standard_EXPORT StepDimTol_GeometricToleranceWithDatumReference();
- //! Initialize all fields (own and inherited)
+ //! Initialize all fields (own and inherited) AP214
Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& aGeometricTolerance_Name, const Handle(TCollection_HAsciiString)& aGeometricTolerance_Description, const Handle(StepBasic_MeasureWithUnit)& aGeometricTolerance_Magnitude, const Handle(StepRepr_ShapeAspect)& aGeometricTolerance_TolerancedShapeAspect, const Handle(StepDimTol_HArray1OfDatumReference)& aDatumSystem);
+
+ //! Initialize all fields (own and inherited) AP242
+ Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& aGeometricTolerance_Name, const Handle(TCollection_HAsciiString)& aGeometricTolerance_Description, const Handle(StepBasic_MeasureWithUnit)& aGeometricTolerance_Magnitude, const StepDimTol_GeometricToleranceTarget& aGeometricTolerance_TolerancedShapeAspect, const Handle(StepDimTol_HArray1OfDatumSystemOrReference)& aDatumSystem);
- //! Returns field DatumSystem
+ //! Returns field DatumSystem AP214
Standard_EXPORT Handle(StepDimTol_HArray1OfDatumReference) DatumSystem() const;
+
+ //! Returns field DatumSystem AP242
+ Standard_EXPORT Handle(StepDimTol_HArray1OfDatumSystemOrReference) DatumSystemAP242() const;
- //! Set field DatumSystem
+ //! Set field DatumSystem AP214
Standard_EXPORT void SetDatumSystem (const Handle(StepDimTol_HArray1OfDatumReference)& DatumSystem);
+
+ //! Set field DatumSystem AP242
+ Standard_EXPORT void SetDatumSystem (const Handle(StepDimTol_HArray1OfDatumSystemOrReference)& DatumSystem);
private:
- Handle(StepDimTol_HArray1OfDatumReference) theDatumSystem;
+ Handle(StepDimTol_HArray1OfDatumSystemOrReference) theDatumSystem;
};
--- /dev/null
+// Created on: 2015-07-07
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepDimTol_GeometricToleranceWithDefinedAreaUnit.hxx>
+
+//=======================================================================
+//function : StepDimTol_GeometricToleranceWithDefinedAreaUnit
+//purpose :
+//=======================================================================
+
+StepDimTol_GeometricToleranceWithDefinedAreaUnit::StepDimTol_GeometricToleranceWithDefinedAreaUnit ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepDimTol_GeometricToleranceWithDefinedAreaUnit::
+ Init (const Handle(TCollection_HAsciiString) &theName,
+ const Handle(TCollection_HAsciiString) &theDescription,
+ const Handle(StepBasic_MeasureWithUnit) &theMagnitude,
+ const StepDimTol_GeometricToleranceTarget &theTolerancedShapeAspect,
+ const Handle(StepBasic_LengthMeasureWithUnit) &theUnitSize,
+ const StepDimTol_AreaUnitType theUnitType,
+ const Standard_Boolean hasSecondUnitSize,
+ const Handle(StepBasic_LengthMeasureWithUnit) &theSecondUnitSize)
+{
+ StepDimTol_GeometricToleranceWithDefinedUnit::
+ Init(theName, theDescription, theMagnitude, theTolerancedShapeAspect, theUnitSize);
+ areaType = theUnitType;
+ if (hasSecondUnitSize)
+ secondUnitSize = theSecondUnitSize;
+ else
+ secondUnitSize.Nullify();
+}
--- /dev/null
+// Created on: 2015-07-07
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_GeometricToleranceWithDefinedAreaUnit_HeaderFile
+#define _StepDimTol_GeometricToleranceWithDefinedAreaUnit_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <Standard_Boolean.hxx>
+#include <StepDimTol_AreaUnitType.hxx>
+#include <StepDimTol_GeometricToleranceWithDefinedUnit.hxx>
+
+class StepBasic_LengthMeasureWithUnit;
+class TCollection_HAsciiString;
+class StepBasic_MeasureWithUnit;
+class StepDimTol_GeometricToleranceTarget;
+
+class StepDimTol_GeometricToleranceWithDefinedAreaUnit;
+DEFINE_STANDARD_HANDLE(StepDimTol_GeometricToleranceWithDefinedAreaUnit, StepDimTol_GeometricToleranceWithDefinedUnit)
+//! Representation of STEP entity GeometricToleranceWithDefinedAreaUnit
+class StepDimTol_GeometricToleranceWithDefinedAreaUnit : public StepDimTol_GeometricToleranceWithDefinedUnit
+{
+
+public:
+
+
+ //! Empty constructor
+ Standard_EXPORT StepDimTol_GeometricToleranceWithDefinedAreaUnit();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& theName, const Handle(TCollection_HAsciiString)& theDescription, const Handle(StepBasic_MeasureWithUnit)& theMagnitude, const StepDimTol_GeometricToleranceTarget& theTolerancedShapeAspect, const Handle(StepBasic_LengthMeasureWithUnit)& theUnitSize, const StepDimTol_AreaUnitType theAreaType, const Standard_Boolean hasSecondUnitSize, const Handle(StepBasic_LengthMeasureWithUnit)& theSecondUnitSize) ;
+
+ //! Returns field AreaType
+ inline StepDimTol_AreaUnitType AreaType () const
+ {
+ return areaType;
+ }
+
+ //! Set field AreaType
+ inline void SetAreaType (const StepDimTol_AreaUnitType theAreaType)
+ {
+ areaType = theAreaType;
+ }
+
+ //! Returns field SecondUnitSize
+ inline Handle(StepBasic_LengthMeasureWithUnit) SecondUnitSize () const
+ {
+ return secondUnitSize;
+ }
+
+ //! Set field SecondUnitSize
+ inline void SetSecondUnitSize (const Handle(StepBasic_LengthMeasureWithUnit) &theSecondUnitSize)
+ {
+ secondUnitSize = theSecondUnitSize;
+ }
+
+ //! Indicates if SecondUnitSize field exist
+ inline Standard_Boolean HasSecondUnitSize () const
+ {
+ return secondUnitSize.IsNull();
+ }
+
+ DEFINE_STANDARD_RTTI(StepDimTol_GeometricToleranceWithDefinedAreaUnit, StepDimTol_GeometricToleranceWithDefinedUnit)
+
+private:
+ StepDimTol_AreaUnitType areaType;
+ Handle(StepBasic_LengthMeasureWithUnit) secondUnitSize;
+};
+#endif // _StepDimTol_GeometricToleranceWithDefinedAreaUnit_HeaderFile
--- /dev/null
+// Created on: 2015-07-07
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepDimTol_GeometricToleranceWithDefinedUnit.hxx>
+
+#include <StepDimTol_GeometricToleranceTarget.hxx>
+#include <StepRepr_ShapeAspect.hxx>
+
+//=======================================================================
+//function : StepDimTol_GeometricToleranceWithDefinedUnit
+//purpose :
+//=======================================================================
+
+StepDimTol_GeometricToleranceWithDefinedUnit::StepDimTol_GeometricToleranceWithDefinedUnit ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepDimTol_GeometricToleranceWithDefinedUnit::Init (const Handle(TCollection_HAsciiString) &theName,
+ const Handle(TCollection_HAsciiString) &theDescription,
+ const Handle(StepBasic_MeasureWithUnit) &theMagnitude,
+ const Handle(StepRepr_ShapeAspect) &theTolerancedShapeAspect,
+ const Handle(StepBasic_LengthMeasureWithUnit) &theUnitSize)
+{
+ StepDimTol_GeometricTolerance::Init(theName, theDescription, theMagnitude, theTolerancedShapeAspect);
+ unitSize = theUnitSize;
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepDimTol_GeometricToleranceWithDefinedUnit::Init (const Handle(TCollection_HAsciiString) &theName,
+ const Handle(TCollection_HAsciiString) &theDescription,
+ const Handle(StepBasic_MeasureWithUnit) &theMagnitude,
+ const StepDimTol_GeometricToleranceTarget &theTolerancedShapeAspect,
+ const Handle(StepBasic_LengthMeasureWithUnit) &theUnitSize)
+{
+ StepDimTol_GeometricTolerance::Init(theName, theDescription, theMagnitude, theTolerancedShapeAspect);
+ unitSize = theUnitSize;
+}
--- /dev/null
+// Created on: 2015-07-07
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_GeometricToleranceWithDefinedUnit_HeaderFile
+#define _StepDimTol_GeometricToleranceWithDefinedUnit_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepDimTol_GeometricTolerance.hxx>
+
+class StepBasic_LengthMeasureWithUnit;
+class TCollection_HAsciiString;
+class StepBasic_MeasureWithUnit;
+class StepDimTol_GeometricToleranceTarget;
+class StepRepr_ShapeAspect;
+
+class StepDimTol_GeometricToleranceWithDefinedUnit;
+DEFINE_STANDARD_HANDLE(StepDimTol_GeometricToleranceWithDefinedUnit, StepDimTol_GeometricTolerance)
+//! Representation of STEP entity GeometricToleranceWithDefinedUnit
+class StepDimTol_GeometricToleranceWithDefinedUnit : public StepDimTol_GeometricTolerance
+{
+
+public:
+
+ //! Empty constructor
+ Standard_EXPORT StepDimTol_GeometricToleranceWithDefinedUnit();
+
+ //! Initialize all fields (own and inherited) AP214
+ Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& theName, const Handle(TCollection_HAsciiString)& theDescription, const Handle(StepBasic_MeasureWithUnit)& theMagnitude, const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect, const Handle(StepBasic_LengthMeasureWithUnit)& theUnitSize) ;
+
+ //! Initialize all fields (own and inherited) AP242
+ Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& theName, const Handle(TCollection_HAsciiString)& theDescription, const Handle(StepBasic_MeasureWithUnit)& theMagnitude, const StepDimTol_GeometricToleranceTarget& theTolerancedShapeAspect, const Handle(StepBasic_LengthMeasureWithUnit)& theUnitSize) ;
+
+ //! Returns field UnitSize
+ inline Handle(StepBasic_LengthMeasureWithUnit) UnitSize () const
+ {
+ return unitSize;
+ }
+
+ //! Set field UnitSize
+ inline void SetUnitSize (const Handle(StepBasic_LengthMeasureWithUnit) &theUnitSize)
+ {
+ unitSize = theUnitSize;
+ }
+
+ DEFINE_STANDARD_RTTI(StepDimTol_GeometricToleranceWithDefinedUnit, StepDimTol_GeometricTolerance)
+
+private:
+ Handle(StepBasic_LengthMeasureWithUnit) unitSize;
+};
+#endif // _StepDimTol_GeometricToleranceWithDefinedUnit_HeaderFile
--- /dev/null
+// Created on: 2015-07-07
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepDimTol_GeometricToleranceWithMaximumTolerance.hxx>
+
+#include <StepBasic_LengthMeasureWithUnit.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
+
+//=======================================================================
+//function : StepDimTol_GeometricToleranceWithModifiers
+//purpose :
+//=======================================================================
+
+StepDimTol_GeometricToleranceWithMaximumTolerance::StepDimTol_GeometricToleranceWithMaximumTolerance ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepDimTol_GeometricToleranceWithMaximumTolerance::
+ Init (const Handle(TCollection_HAsciiString) &theName,
+ const Handle(TCollection_HAsciiString) &theDescription,
+ const Handle(StepBasic_MeasureWithUnit) &theMagnitude,
+ const StepDimTol_GeometricToleranceTarget &theTolerancedShapeAspect,
+ const Handle(StepDimTol_HArray1OfGeometricToleranceModifier) &theModifiers,
+ const Handle(StepBasic_LengthMeasureWithUnit) &theMaximumUpperTolerance)
+{
+ StepDimTol_GeometricToleranceWithModifiers::Init(theName, theDescription, theMagnitude, theTolerancedShapeAspect, theModifiers);
+ maximumUpperTolerance = theMaximumUpperTolerance;
+}
--- /dev/null
+// Created on: 2015-07-07
+// Created by: Irina KRYLOVA
+// 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. to be the "object code" form of the original source.
+
+#ifndef _StepDimTol_GeometricToleranceWithMaximumTolerance_HeaderFile
+#define _StepDimTol_GeometricToleranceWithMaximumTolerance_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepBasic_LengthMeasureWithUnit.hxx>
+#include <StepDimTol_GeometricToleranceWithModifiers.hxx>
+
+class TCollection_HAsciiString;
+class StepBasic_MeasureWithUnit;
+class StepDimTol_GeometricToleranceTarget;
+class StepDimTol_HArray1OfGeometricToleranceModifier;
+
+class StepDimTol_GeometricToleranceWithMaximumTolerance;
+DEFINE_STANDARD_HANDLE(StepDimTol_GeometricToleranceWithMaximumTolerance, StepDimTol_GeometricToleranceWithModifiers)
+//! Representation of STEP entity GeometricToleranceWithMaximumTolerance
+class StepDimTol_GeometricToleranceWithMaximumTolerance : public StepDimTol_GeometricToleranceWithModifiers
+{
+
+public:
+
+ //! Empty constructor
+ Standard_EXPORT StepDimTol_GeometricToleranceWithMaximumTolerance();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& theName, const Handle(TCollection_HAsciiString)& theDescription, const Handle(StepBasic_MeasureWithUnit)& theMagnitude, const StepDimTol_GeometricToleranceTarget& theTolerancedShapeAspect, const Handle(StepDimTol_HArray1OfGeometricToleranceModifier)& theModifiers, const Handle(StepBasic_LengthMeasureWithUnit)& theUnitSize) ;
+
+ //! Returns field MaximumUpperTolerance
+ inline Handle(StepBasic_LengthMeasureWithUnit) MaximumUpperTolerance () const
+ {
+ return maximumUpperTolerance;
+ }
+
+ //! Set field MaximumUpperTolerance
+ inline void SetMaximumUpperTolerance (const Handle(StepBasic_LengthMeasureWithUnit) &theMaximumUpperTolerance)
+ {
+ maximumUpperTolerance = theMaximumUpperTolerance;
+ }
+
+ DEFINE_STANDARD_RTTI(StepDimTol_GeometricToleranceWithMaximumTolerance, StepDimTol_GeometricToleranceWithModifiers)
+
+private:
+ Handle(StepBasic_LengthMeasureWithUnit) maximumUpperTolerance;
+};
+#endif // _StepDimTol_GeometricToleranceWithMaximumTolerance_HeaderFile
--- /dev/null
+// Created on: 2015-07-07
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepDimTol_GeometricToleranceWithModifiers.hxx>
+
+#include <StepDimTol_GeometricToleranceTarget.hxx>
+#include <StepDimTol_HArray1OfGeometricToleranceModifier.hxx>
+
+//=======================================================================
+//function : StepDimTol_GeometricToleranceWithModifiers
+//purpose :
+//=======================================================================
+
+StepDimTol_GeometricToleranceWithModifiers::StepDimTol_GeometricToleranceWithModifiers ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepDimTol_GeometricToleranceWithModifiers::Init (const Handle(TCollection_HAsciiString) &theName,
+ const Handle(TCollection_HAsciiString) &theDescription,
+ const Handle(StepBasic_MeasureWithUnit) &theMagnitude,
+ const StepDimTol_GeometricToleranceTarget &theTolerancedShapeAspect,
+ const Handle(StepDimTol_HArray1OfGeometricToleranceModifier) &theModifiers)
+{
+ StepDimTol_GeometricTolerance::Init(theName, theDescription, theMagnitude, theTolerancedShapeAspect);
+ modifiers = theModifiers;
+}
--- /dev/null
+// Created on: 2015-07-07
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_GeometricToleranceWithModifiers_HeaderFile
+#define _StepDimTol_GeometricToleranceWithModifiers_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <Standard_Integer.hxx>
+#include <StepDimTol_GeometricTolerance.hxx>
+#include <StepDimTol_GeometricToleranceModifier.hxx>
+#include <StepDimTol_HArray1OfGeometricToleranceModifier.hxx>
+
+class StepDimTol_HArray1OfGeometricToleranceModifier;
+class TCollection_HAsciiString;
+class StepBasic_MeasureWithUnit;
+class StepDimTol_GeometricToleranceTarget;
+
+class StepDimTol_GeometricToleranceWithModifiers;
+DEFINE_STANDARD_HANDLE(StepDimTol_GeometricToleranceWithModifiers, StepDimTol_GeometricTolerance)
+//! Representation of STEP entity GeometricToleranceWithModifiers
+class StepDimTol_GeometricToleranceWithModifiers : public StepDimTol_GeometricTolerance
+{
+
+public:
+
+ //! Empty constructor
+ Standard_EXPORT StepDimTol_GeometricToleranceWithModifiers();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& theName,
+ const Handle(TCollection_HAsciiString)& theDescription,
+ const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const StepDimTol_GeometricToleranceTarget& theTolerancedShapeAspect,
+ const Handle(StepDimTol_HArray1OfGeometricToleranceModifier)& theModifiers) ;
+
+ //! Returns field Modifiers
+ inline Handle(StepDimTol_HArray1OfGeometricToleranceModifier) Modifiers () const
+ {
+ return modifiers;
+ }
+
+ //! Set field Modifiers
+ inline void SetModifiers (const Handle(StepDimTol_HArray1OfGeometricToleranceModifier) &theModifiers)
+ {
+ modifiers = theModifiers;
+ }
+
+ //! Returns number of modifiers
+ inline Standard_Integer NbModifiers () const
+ {
+ return (modifiers.IsNull() ? 0 : modifiers->Length());
+ }
+
+ //! Returns modifier with the given number
+ inline StepDimTol_GeometricToleranceModifier ModifierValue(const Standard_Integer num) const
+ {
+ return modifiers->Value(num);
+ }
+
+ //! Sets modifier with given number
+ inline void SetModifierValue(const Standard_Integer num, const StepDimTol_GeometricToleranceModifier theItem)
+ {
+ modifiers->SetValue (num, theItem);
+ }
+ DEFINE_STANDARD_RTTI(StepDimTol_GeometricToleranceWithModifiers, StepDimTol_GeometricTolerance)
+
+private:
+ Handle(StepDimTol_HArray1OfGeometricToleranceModifier) modifiers;
+};
+#endif // _StepDimTol_GeometricToleranceWithModifiers_HeaderFile
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_HArray1OfDatumReferenceCompartment_HeaderFile
+#define _StepDimTol_HArray1OfDatumReferenceCompartment_HeaderFile
+
+#include <StepDimTol_DatumReferenceCompartment.hxx>
+#include <StepDimTol_Array1OfDatumReferenceCompartment.hxx>
+#include <NCollection_DefineHArray1.hxx>
+
+DEFINE_HARRAY1(StepDimTol_HArray1OfDatumReferenceCompartment, StepDimTol_Array1OfDatumReferenceCompartment)
+#endif // _StepDimTol_HArray1OfDatumReferenceCompartment_HeaderFile
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_HArray1OfDatumReferenceElement_HeaderFile
+#define _StepDimTol_HArray1OfDatumReferenceElement_HeaderFile
+
+#include <StepDimTol_DatumReferenceElement.hxx>
+#include <StepDimTol_Array1OfDatumReferenceElement.hxx>
+#include <NCollection_DefineHArray1.hxx>
+
+DEFINE_HARRAY1(StepDimTol_HArray1OfDatumReferenceElement, StepDimTol_Array1OfDatumReferenceElement)
+#endif // _StepDimTol_HArray1OfDatumReferenceElement_HeaderFile
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_HArray1OfDatumReferenceModifier_HeaderFile
+#define _StepDimTol_HArray1OfDatumReferenceModifier_HeaderFile
+
+#include <StepDimTol_DatumReferenceModifier.hxx>
+#include <StepDimTol_Array1OfDatumReferenceModifier.hxx>
+#include <NCollection_DefineHArray1.hxx>
+
+DEFINE_HARRAY1(StepDimTol_HArray1OfDatumReferenceModifier, StepDimTol_Array1OfDatumReferenceModifier)
+
+#endif // _StepDimTol_HArray1OfDatumReferenceModifier_HeaderFile
--- /dev/null
+// Created on: 2015-07-21
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_HArray1OfDatumSystemOrReference_HeaderFile
+#define _StepDimTol_HArray1OfDatumSystemOrReference_HeaderFile
+
+#include <StepDimTol_DatumSystemOrReference.hxx>
+#include <StepDimTol_Array1OfDatumSystemOrReference.hxx>
+#include <NCollection_DefineHArray1.hxx>
+
+DEFINE_HARRAY1(StepDimTol_HArray1OfDatumSystemOrReference, StepDimTol_Array1OfDatumSystemOrReference)
+#endif // _StepDimTol_HArray1OfDatumSystemOrReference_HeaderFile
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_HArray1OfGeometricToleranceModifier_HeaderFile
+#define _StepDimTol_HArray1OfGeometricToleranceModifier_HeaderFile
+
+#include <StepDimTol_GeometricToleranceModifier.hxx>
+#include <StepDimTol_Array1OfGeometricToleranceModifier.hxx>
+#include <NCollection_DefineHArray1.hxx>
+
+DEFINE_HARRAY1(StepDimTol_HArray1OfGeometricToleranceModifier, StepDimTol_Array1OfGeometricToleranceModifier)
+#endif // _StepDimTol_HArray1OfGeometricToleranceModifier_HeaderFile
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_HArray1OfToleranceZoneTarget_HeaderFile
+#define _StepDimTol_HArray1OfToleranceZoneTarget_HeaderFile
+
+#include <StepDimTol_ToleranceZoneTarget.hxx>
+#include <StepDimTol_Array1OfToleranceZoneTarget.hxx>
+#include <NCollection_DefineHArray1.hxx>
+
+DEFINE_HARRAY1(StepDimTol_HArray1OfToleranceZoneTarget, StepDimTol_Array1OfToleranceZoneTarget)
+#endif // _StepDimTol_HArray1OfToleranceZoneTarget_HeaderFile
#include <Standard_Type.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepDimTol_ModifiedGeometricTolerance.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
#include <StepRepr_ShapeAspect.hxx>
#include <TCollection_HAsciiString.hxx>
theModifier = aModifier;
}
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepDimTol_ModifiedGeometricTolerance::Init (const Handle(TCollection_HAsciiString) &aGeometricTolerance_Name,
+ const Handle(TCollection_HAsciiString) &aGeometricTolerance_Description,
+ const Handle(StepBasic_MeasureWithUnit) &aGeometricTolerance_Magnitude,
+ const StepDimTol_GeometricToleranceTarget &aGeometricTolerance_TolerancedShapeAspect,
+ const StepDimTol_LimitCondition aModifier)
+{
+ StepDimTol_GeometricTolerance::Init(aGeometricTolerance_Name,
+ aGeometricTolerance_Description,
+ aGeometricTolerance_Magnitude,
+ aGeometricTolerance_TolerancedShapeAspect);
+
+ theModifier = aModifier;
+}
+
//=======================================================================
//function : Modifier
//purpose :
#include <StepDimTol_GeometricTolerance.hxx>
class TCollection_HAsciiString;
class StepBasic_MeasureWithUnit;
+class StepDimTol_GeometricToleranceTarget;
class StepRepr_ShapeAspect;
//! Empty constructor
Standard_EXPORT StepDimTol_ModifiedGeometricTolerance();
- //! Initialize all fields (own and inherited)
+ //! Initialize all fields (own and inherited) AP214
Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& aGeometricTolerance_Name, const Handle(TCollection_HAsciiString)& aGeometricTolerance_Description, const Handle(StepBasic_MeasureWithUnit)& aGeometricTolerance_Magnitude, const Handle(StepRepr_ShapeAspect)& aGeometricTolerance_TolerancedShapeAspect, const StepDimTol_LimitCondition aModifier);
-
+
+ //! Initialize all fields (own and inherited) AP242
+ Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& aGeometricTolerance_Name, const Handle(TCollection_HAsciiString)& aGeometricTolerance_Description, const Handle(StepBasic_MeasureWithUnit)& aGeometricTolerance_Magnitude, const StepDimTol_GeometricToleranceTarget& aGeometricTolerance_TolerancedShapeAspect, const StepDimTol_LimitCondition aModifier);
+
//! Returns field Modifier
Standard_EXPORT StepDimTol_LimitCondition Modifier() const;
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepDimTol_NonUniformZoneDefinition.hxx>
+
+//=======================================================================
+//function : StepDimTol_NonUniformZoneDefinition
+//purpose :
+//=======================================================================
+
+StepDimTol_NonUniformZoneDefinition::StepDimTol_NonUniformZoneDefinition ()
+{
+}
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_NonUniformZoneDefinition_HeaderFile
+#define _StepDimTol_NonUniformZoneDefinition_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepDimTol_ToleranceZoneDefinition.hxx>
+
+class StepDimTol_NonUniformZoneDefinition;
+DEFINE_STANDARD_HANDLE(StepDimTol_NonUniformZoneDefinition, StepDimTol_ToleranceZoneDefinition)
+//! Representation of STEP entity NonUniformZoneDefinition
+class StepDimTol_NonUniformZoneDefinition : public StepDimTol_ToleranceZoneDefinition
+{
+
+public:
+
+ //! Empty constructor
+ Standard_EXPORT StepDimTol_NonUniformZoneDefinition();
+
+ DEFINE_STANDARD_RTTI(StepDimTol_NonUniformZoneDefinition, StepDimTol_ToleranceZoneDefinition)
+};
+#endif // _StepDimTol_NonUniformZoneDefinition_HeaderFile
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepDimTol_ProjectedZoneDefinition.hxx>
+
+//=======================================================================
+//function : StepDimTol_ProjectedZoneDefinition
+//purpose :
+//=======================================================================
+
+StepDimTol_ProjectedZoneDefinition::StepDimTol_ProjectedZoneDefinition ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepDimTol_ProjectedZoneDefinition::Init (const Handle(StepDimTol_ToleranceZone)& theZone,
+ const Handle(StepRepr_HArray1OfShapeAspect)& theBoundaries,
+ const Handle(StepRepr_ShapeAspect)& theProjectionEnd,
+ const Handle(StepBasic_LengthMeasureWithUnit)& theProjectionLength)
+{
+ StepDimTol_ToleranceZoneDefinition::Init(theZone, theBoundaries);
+ projectionEnd = theProjectionEnd;
+ projectionLength = theProjectionLength;
+}
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_ProjectedZoneDefinition_HeaderFile
+#define _StepDimTol_ProjectedZoneDefinition_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <Standard_Integer.hxx>
+#include <StepBasic_LengthMeasureWithUnit.hxx>
+#include <StepDimTol_ToleranceZoneDefinition.hxx>
+#include <StepRepr_ShapeAspect.hxx>
+
+class StepDimTol_ProjectedZoneDefinition;
+DEFINE_STANDARD_HANDLE(StepDimTol_ProjectedZoneDefinition, StepDimTol_ToleranceZoneDefinition)
+//! Representation of STEP entity ProjectedZoneDefinition
+class StepDimTol_ProjectedZoneDefinition : public StepDimTol_ToleranceZoneDefinition
+{
+
+public:
+
+ //! Empty constructor
+ Standard_EXPORT StepDimTol_ProjectedZoneDefinition();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init (const Handle(StepDimTol_ToleranceZone)& theZone,
+ const Handle(StepRepr_HArray1OfShapeAspect)& theBoundaries,
+ const Handle(StepRepr_ShapeAspect)& theProjectionEnd,
+ const Handle(StepBasic_LengthMeasureWithUnit)& theProjectionLength);
+
+ //! Returns field ProjectionEnd
+ inline Handle(StepRepr_ShapeAspect) ProjectionEnd () const
+ {
+ return projectionEnd;
+ }
+
+ //! Set field ProjectionEnd
+ inline void SetProjectionEnd (const Handle(StepRepr_ShapeAspect) &theProjectionEnd)
+ {
+ projectionEnd = theProjectionEnd;
+ }
+
+ //! Returns field ProjectionLength
+ inline Handle(StepBasic_LengthMeasureWithUnit) ProjectionLength()
+ {
+ return projectionLength;
+ }
+
+ //! Set field ProjectionLength
+ inline void SetProjectionLength(const Handle(StepBasic_LengthMeasureWithUnit)& theProjectionLength)
+ {
+ projectionLength = theProjectionLength;
+ }
+
+ DEFINE_STANDARD_RTTI(StepDimTol_ProjectedZoneDefinition, StepDimTol_ToleranceZoneDefinition)
+
+private:
+ Handle(StepRepr_ShapeAspect) projectionEnd;
+ Handle(StepBasic_LengthMeasureWithUnit) projectionLength;
+};
+#endif // _StepDimTol_ProjectionZoneDefinition_HeaderFile
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepDimTol_RunoutZoneDefinition.hxx>
+
+#include <StepRepr_HArray1OfShapeAspect.hxx>
+#include <StepDimTol_RunoutZoneOrientation.hxx>
+
+//=======================================================================
+//function : StepDimTol_RunoutZoneDefinition
+//purpose :
+//=======================================================================
+
+StepDimTol_RunoutZoneDefinition::StepDimTol_RunoutZoneDefinition ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepDimTol_RunoutZoneDefinition:: Init (const Handle(StepDimTol_ToleranceZone)& theZone,
+ const Handle(StepRepr_HArray1OfShapeAspect)& theBoundaries,
+ const Handle(StepDimTol_RunoutZoneOrientation)& theOrientation)
+{
+ StepDimTol_ToleranceZoneDefinition::Init(theZone, theBoundaries);
+ orientation = theOrientation;
+}
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_RunoutZoneDefinition_HeaderFile
+#define _StepDimTol_RunoutZoneDefinition_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepDimTol_RunoutZoneOrientation.hxx>
+#include <StepDimTol_ToleranceZoneDefinition.hxx>
+#include <Standard_Integer.hxx>
+
+class StepRepr_HArray1OfShapeAspect;
+
+class StepDimTol_RunoutZoneDefinition;
+DEFINE_STANDARD_HANDLE(StepDimTol_RunoutZoneDefinition, StepDimTol_ToleranceZoneDefinition)
+//! Representation of STEP entity ToleranceZoneDefinition
+class StepDimTol_RunoutZoneDefinition : public StepDimTol_ToleranceZoneDefinition
+{
+
+public:
+
+ //! Empty constructor
+ Standard_EXPORT StepDimTol_RunoutZoneDefinition();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init (const Handle(StepDimTol_ToleranceZone)& theZone,
+ const Handle(StepRepr_HArray1OfShapeAspect)& theBoundaries,
+ const Handle(StepDimTol_RunoutZoneOrientation)& theOrientation);
+
+ //! Returns field Orientation
+ inline Handle(StepDimTol_RunoutZoneOrientation) Orientation () const
+ {
+ return orientation;
+ }
+
+ //! Set field Orientation
+ inline void SetOrientation (const Handle(StepDimTol_RunoutZoneOrientation) &theOrientation)
+ {
+ orientation = theOrientation;
+ }
+
+ DEFINE_STANDARD_RTTI(StepDimTol_ToleranceZoneDefinition, StepDimTol_ToleranceZoneDefinition)
+
+private:
+ Handle(StepDimTol_RunoutZoneOrientation) orientation;
+};
+#endif // _StepDimTol_RunoutToleranceZone_HeaderFile
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepDimTol_RunoutZoneOrientation.hxx>
+
+//=======================================================================
+//function : StepDimTol_RunoutZoneOrientation
+//purpose :
+//=======================================================================
+
+StepDimTol_RunoutZoneOrientation::StepDimTol_RunoutZoneOrientation () {}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepDimTol_RunoutZoneOrientation::Init(
+ const Handle(StepBasic_PlaneAngleMeasureWithUnit)& theAngle)
+{
+ // --- class own fields ---
+ angle = theAngle;
+}
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_RunoutZoneOrientation_HeaderFile
+#define _StepDimTol_RunoutZoneOrientation_HeaderFile
+
+#include <StepDimTol_RunoutZoneOrientation.hxx>
+
+#include <MMgt_TShared.hxx>
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepBasic_PlaneAngleMeasureWithUnit.hxx>
+
+class StepDimTol_RunoutZoneOrientation;
+DEFINE_STANDARD_HANDLE(StepDimTol_RunoutZoneOrientation, MMgt_TShared)
+//! Added for Dimensional Tolerances
+class StepDimTol_RunoutZoneOrientation : public MMgt_TShared
+{
+
+public:
+
+ Standard_EXPORT StepDimTol_RunoutZoneOrientation();
+
+ //! Init all field own and inherited
+ Standard_EXPORT virtual void Init (const Handle(StepBasic_PlaneAngleMeasureWithUnit)& theAngle);
+
+ //! Returns field Angle
+ inline Handle(StepBasic_PlaneAngleMeasureWithUnit) Angle()
+ {
+ return angle;
+ }
+
+ //! Set field Angle
+ inline void SetAngle(const Handle(StepBasic_PlaneAngleMeasureWithUnit) &theAngle)
+ {
+ angle = theAngle;
+ }
+
+ DEFINE_STANDARD_RTTI(StepDimTol_RunoutZoneOrientation, MMgt_TShared)
+
+private:
+ Handle(StepBasic_PlaneAngleMeasureWithUnit) angle;
+
+};
+#endif // _StepDimTol_RunoutZoneOrientation_HeaderFile
--- /dev/null
+// Created on: 2015-07-14
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_SimpleDatumReferenceModifier_HeaderFile
+#define _StepDimTol_SimpleDatumReferenceModifier_HeaderFile
+
+#include <Standard_PrimitiveTypes.hxx>
+
+enum StepDimTol_SimpleDatumReferenceModifier {
+ StepDimTol_SDRMAnyCrossSection,
+ StepDimTol_SDRMAnyLongitudinalSection,
+ StepDimTol_SDRMBasic,
+ StepDimTol_SDRMContactingFeature,
+ StepDimTol_SDRMDegreeOfFreedomConstraintU,
+ StepDimTol_SDRMDegreeOfFreedomConstraintV,
+ StepDimTol_SDRMDegreeOfFreedomConstraintW,
+ StepDimTol_SDRMDegreeOfFreedomConstraintX,
+ StepDimTol_SDRMDegreeOfFreedomConstraintY,
+ StepDimTol_SDRMDegreeOfFreedomConstraintZ,
+ StepDimTol_SDRMDistanceVariable,
+ StepDimTol_SDRMFreeState,
+ StepDimTol_SDRMLeastMaterialRequirement,
+ StepDimTol_SDRMLine,
+ StepDimTol_SDRMMajorDiameter,
+ StepDimTol_SDRMMaximumMaterialRequirement,
+ StepDimTol_SDRMMinorDiameter,
+ StepDimTol_SDRMOrientation,
+ StepDimTol_SDRMPitchDiameter,
+ StepDimTol_SDRMPlane,
+ StepDimTol_SDRMPoint,
+ StepDimTol_SDRMTranslation
+};
+
+#endif
\ No newline at end of file
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepDimTol_SimpleDatumReferenceModifierMember.hxx>
+#include <StepData_EnumTool.hxx>
+#include <TCollection_AsciiString.hxx>
+
+static StepData_EnumTool tool
+ (".ANY_CROSS_SECTION.",
+ ".ANY_LONGITUDINAL_SECTION.",
+ ".BASIC.",
+ ".CONTACTING_FEATURE.",
+ ".DEGREE_OF_FREEDOM_CONSTRAINT_U.",
+ ".DEGREE_OF_FREEDOM_CONSTRAINT_V.",
+ ".DEGREE_OF_FREEDOM_CONSTRAINT_W.",
+ ".DEGREE_OF_FREEDOM_CONSTRAINT_X.",
+ ".DEGREE_OF_FREEDOM_CONSTRAINT_Y.",
+ ".DEGREE_OF_FREEDOM_CONSTRAINT_Z.",
+ ".DISTANCE_VARIABLE.",
+ ".FREE_STATE.",
+ ".LEAST_MATERIAL_REQUIREMENT.",
+ ".LINE.",
+ ".MAJOR_DIAMETER.",
+ ".MAXIMUM_MATERIAL_REQUIREMENT.",
+ ".MINOR_DIAMETER.",
+ ".ORIENTATION.",
+ ".PITCH_DIAMETER.",
+ ".PLANE.",
+ ".POINT.",
+ ".TRANSLATION.");
+
+//=======================================================================
+//function : StepDimTol_SimpleDatumReferenceModifierMember
+//purpose :
+//=======================================================================
+
+StepDimTol_SimpleDatumReferenceModifierMember::StepDimTol_SimpleDatumReferenceModifierMember () { }
+
+//=======================================================================
+//function : EnumText
+//purpose :
+//=======================================================================
+
+Standard_CString StepDimTol_SimpleDatumReferenceModifierMember::EnumText () const
+ { return tool.Text(Int()).ToCString(); }
+
+//=======================================================================
+//function : SetEnumText
+//purpose :
+//=======================================================================
+
+void StepDimTol_SimpleDatumReferenceModifierMember::SetEnumText (const Standard_Integer /*theValue*/,
+ const Standard_CString theText)
+{
+ Standard_Integer aVal = tool.Value (theText);
+ if (aVal >= 0) SetInt (aVal);
+}
+
+//=======================================================================
+//function : SetValue
+//purpose :
+//=======================================================================
+
+void StepDimTol_SimpleDatumReferenceModifierMember::SetValue (const StepDimTol_SimpleDatumReferenceModifier theValue)
+{
+ SetInt ( Standard_Integer (theValue) );
+}
+
+//=======================================================================
+//function : Value
+//purpose :
+//=======================================================================
+
+StepDimTol_SimpleDatumReferenceModifier StepDimTol_SimpleDatumReferenceModifierMember::Value () const
+{
+ return StepDimTol_SimpleDatumReferenceModifier (Int());
+}
+
+
--- /dev/null
+// Created on: 2015-07-16
+// Created by: Irina KRYLOVA
+// 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 _StepVisual_MarkerMember_HeaderFile
+#define _StepVisual_MarkerMember_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepData_SelectInt.hxx>
+#include <Standard_Boolean.hxx>
+#include <Standard_CString.hxx>
+#include <Standard_Integer.hxx>
+#include <StepDimTol_SimpleDatumReferenceModifier.hxx>
+
+class StepDimTol_SimpleDatumReferenceModifierMember;
+DEFINE_STANDARD_HANDLE(StepDimTol_SimpleDatumReferenceModifierMember, StepData_SelectInt)
+//! Defines SimpleDatumReferenceModifier as unique member of DatumReferenceModifier
+//! Works with an EnumTool
+class StepDimTol_SimpleDatumReferenceModifierMember : public StepData_SelectInt
+{
+
+public:
+
+ Standard_EXPORT StepDimTol_SimpleDatumReferenceModifierMember();
+
+ inline Standard_Boolean HasName() const
+ { return Standard_True; }
+
+ inline Standard_CString Name() const
+ { return "SIMPLE_DATUM_REFERENCE_MODIFIER"; }
+
+ inline Standard_Boolean SetName(const Standard_CString /*theName*/)
+ { return Standard_True; }
+
+ Standard_EXPORT virtual Standard_CString EnumText() const;
+
+ Standard_EXPORT virtual void SetEnumText (const Standard_Integer theValue, const Standard_CString theText) ;
+
+ Standard_EXPORT void SetValue (const StepDimTol_SimpleDatumReferenceModifier theValue) ;
+
+ Standard_EXPORT StepDimTol_SimpleDatumReferenceModifier Value() const;
+
+ DEFINE_STANDARD_RTTI(StepDimTol_SimpleDatumReferenceModifierMember, StepData_SelectInt)
+};
+#endif // _StepDimTol_SimpleDatumReferenceModifierMember_HeaderFile
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepDimTol_ToleranceZone.hxx>
+
+#include <StepDimTol_HArray1OfToleranceZoneTarget.hxx>
+
+//=======================================================================
+//function : StepDimTol_ToleranceZone
+//purpose :
+//=======================================================================
+
+StepDimTol_ToleranceZone::StepDimTol_ToleranceZone ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepDimTol_ToleranceZone::Init (const Handle(TCollection_HAsciiString)& theName,
+ const Handle(TCollection_HAsciiString)& theDescription,
+ const Handle(StepRepr_ProductDefinitionShape)& theOfShape,
+ const StepData_Logical theProductDefinitional,
+ const Handle(StepDimTol_HArray1OfToleranceZoneTarget)& theDefiningTolerance,
+ const Handle(StepDimTol_ToleranceZoneForm)& theForm)
+{
+ StepRepr_ShapeAspect::Init(theName, theDescription, theOfShape, theProductDefinitional);
+ definingTolerance = theDefiningTolerance;
+ form = theForm;
+}
+
\ No newline at end of file
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_ToleranceZone_HeaderFile
+#define _StepDimTol_ToleranceZone_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepRepr_ShapeAspect.hxx>
+#include <Standard_Integer.hxx>
+#include <StepDimTol_HArray1OfToleranceZoneTarget.hxx>
+#include <StepDimTol_ToleranceZoneForm.hxx>
+#include <StepDimTol_ToleranceZoneTarget.hxx>
+
+class StepDimTol_HArray1OfToleranceZoneTarget;
+class TCollection_HAsciiString;
+class StepBasic_MeasureWithUnit;
+
+class StepDimTol_ToleranceZone;
+DEFINE_STANDARD_HANDLE(StepDimTol_ToleranceZone, StepRepr_ShapeAspect)
+//! Representation of STEP entity ToleranceZone
+class StepDimTol_ToleranceZone : public StepRepr_ShapeAspect
+{
+
+public:
+
+ //! Empty constructor
+ Standard_EXPORT StepDimTol_ToleranceZone();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& theName,
+ const Handle(TCollection_HAsciiString)& theDescription,
+ const Handle(StepRepr_ProductDefinitionShape)& theOfShape,
+ const StepData_Logical theProductDefinitional,
+ const Handle(StepDimTol_HArray1OfToleranceZoneTarget)& theDefiningTolerance,
+ const Handle(StepDimTol_ToleranceZoneForm)& theForm);
+
+ //! Returns field DefiningTolerance
+ inline Handle(StepDimTol_HArray1OfToleranceZoneTarget) DefiningTolerance () const
+ {
+ return definingTolerance;
+ }
+
+ //! Set field DefiningTolerance
+ inline void SetModifiers (const Handle(StepDimTol_HArray1OfToleranceZoneTarget) &theDefiningTolerance)
+ {
+ definingTolerance = theDefiningTolerance;
+ }
+
+ //! Returns number of Defining Tolerances
+ inline Standard_Integer NbDefiningTolerances () const
+ {
+ return (definingTolerance.IsNull() ? 0 : definingTolerance->Length());
+ }
+
+ //! Returns Defining Tolerance with the given number
+ inline StepDimTol_ToleranceZoneTarget DefiningToleranceValue(const Standard_Integer num) const
+ {
+ return definingTolerance->Value(num);
+ }
+
+ //! Sets Defining Tolerance with given number
+ inline void SetDefiningToleranceValue(const Standard_Integer num, const StepDimTol_ToleranceZoneTarget& theItem)
+ {
+ definingTolerance->SetValue (num, theItem);
+ }
+
+ //! Returns field Form
+ inline Handle(StepDimTol_ToleranceZoneForm) Form()
+ {
+ return form;
+ }
+
+ //! Set field Form
+ inline void SetForm(const Handle(StepDimTol_ToleranceZoneForm)& theForm)
+ {
+ form = theForm;
+ }
+
+ DEFINE_STANDARD_RTTI(StepDimTol_ToleranceZone, StepRepr_ShapeAspect)
+
+private:
+ Handle(StepDimTol_HArray1OfToleranceZoneTarget) definingTolerance;
+ Handle(StepDimTol_ToleranceZoneForm) form;
+};
+#endif // _StepDimTol_ToleranceZone_HeaderFile
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepDimTol_ToleranceZoneDefinition.hxx>
+
+#include <StepRepr_HArray1OfShapeAspect.hxx>
+
+//=======================================================================
+//function : StepDimTol_ToleranceZoneDefinition
+//purpose :
+//=======================================================================
+
+StepDimTol_ToleranceZoneDefinition::StepDimTol_ToleranceZoneDefinition ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepDimTol_ToleranceZoneDefinition::Init (const Handle(StepDimTol_ToleranceZone)& theZone,
+ const Handle(StepRepr_HArray1OfShapeAspect)& theBoundaries)
+{
+ boundaries = theBoundaries;
+ zone = theZone;
+}
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_ToleranceZoneDefinition_HeaderFile
+#define _StepDimTol_ToleranceZoneDefinition_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <MMgt_TShared.hxx>
+#include <Standard_Integer.hxx>
+#include <StepRepr_HArray1OfShapeAspect.hxx>
+#include <StepRepr_ShapeAspect.hxx>
+#include <StepDimTol_ToleranceZone.hxx>
+
+class StepRepr_HArray1OfShapeAspect;
+
+class StepDimTol_ToleranceZoneDefinition;
+DEFINE_STANDARD_HANDLE(StepDimTol_ToleranceZoneDefinition, MMgt_TShared)
+//! Representation of STEP entity ToleranceZoneDefinition
+class StepDimTol_ToleranceZoneDefinition : public MMgt_TShared
+{
+
+public:
+
+ //! Empty constructor
+ Standard_EXPORT StepDimTol_ToleranceZoneDefinition();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init (const Handle(StepDimTol_ToleranceZone)& theZone,
+ const Handle(StepRepr_HArray1OfShapeAspect)& theBoundaries);
+
+ //! Returns field Boundaries
+ inline Handle(StepRepr_HArray1OfShapeAspect) Boundaries () const
+ {
+ return boundaries;
+ }
+
+ //! Set field Boundaries
+ inline void SetBoundaries (const Handle(StepRepr_HArray1OfShapeAspect) &theBoundaries)
+ {
+ boundaries = theBoundaries;
+ }
+
+ //! Returns number of Boundaries
+ inline Standard_Integer NbBoundaries () const
+ {
+ return (boundaries.IsNull() ? 0 : boundaries->Length());
+ }
+
+ //! Returns Boundaries with the given number
+ inline Handle(StepRepr_ShapeAspect) BoundariesValue(const Standard_Integer num) const
+ {
+ return boundaries->Value(num);
+ }
+
+ //! Sets Boundaries with given number
+ inline void SetBoundariesValue(const Standard_Integer num, const Handle(StepRepr_ShapeAspect)& theItem)
+ {
+ boundaries->SetValue (num, theItem);
+ }
+
+ //! Returns field Zone
+ inline Handle(StepDimTol_ToleranceZone) Zone()
+ {
+ return zone;
+ }
+
+ //! Set field Zone
+ inline void SetZone(const Handle(StepDimTol_ToleranceZone)& theZone)
+ {
+ zone = theZone;
+ }
+
+ DEFINE_STANDARD_RTTI(StepDimTol_ToleranceZoneDefinition, MMgt_TShared)
+
+private:
+ Handle(StepRepr_HArray1OfShapeAspect) boundaries;
+ Handle(StepDimTol_ToleranceZone) zone;
+};
+#endif // _StepDimTol_ToleranceZoneDefinition_HeaderFile
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepDimTol_ToleranceZoneForm.hxx>
+
+//=======================================================================
+//function : StepDimTol_ToleranceZoneForm
+//purpose :
+//=======================================================================
+
+StepDimTol_ToleranceZoneForm::StepDimTol_ToleranceZoneForm () {}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepDimTol_ToleranceZoneForm::Init(
+ const Handle(TCollection_HAsciiString)& theName)
+{
+ // --- classe own fields ---
+ name = theName;
+}
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_ToleranceZoneForm_HeaderFile
+#define _StepDimTol_ToleranceZoneForm_HeaderFile
+
+#include <StepDimTol_ToleranceZoneForm.hxx>
+
+#include <MMgt_TShared.hxx>
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <TCollection_HAsciiString.hxx>
+
+class TCollection_HAsciiString;
+
+class StepDimTol_ToleranceZoneForm;
+DEFINE_STANDARD_HANDLE(StepDimTol_ToleranceZoneForm, MMgt_TShared)
+//! Added for Dimensional Tolerances
+class StepDimTol_ToleranceZoneForm : public MMgt_TShared
+{
+
+public:
+
+ Standard_EXPORT StepDimTol_ToleranceZoneForm();
+
+ //! Init all field own and inherited
+ Standard_EXPORT virtual void Init (const Handle(TCollection_HAsciiString)& theName);
+
+ //! Returns field Name
+ inline Handle(TCollection_HAsciiString) Name()
+ {
+ return name;
+ }
+
+ //! Set field Name
+ inline void SetName(const Handle(TCollection_HAsciiString) &theName)
+ {
+ name = theName;
+ }
+
+ DEFINE_STANDARD_RTTI(StepDimTol_ToleranceZoneForm, MMgt_TShared)
+
+private:
+ Handle(TCollection_HAsciiString) name;
+
+};
+#endif // _StepDimTol_ToleranceZoneForm_HeaderFile
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepDimTol_ToleranceZoneTarget.hxx>
+#include <Interface_Macros.hxx>
+#include <StepShape_DimensionalLocation.hxx>
+#include <StepShape_DimensionalSize.hxx>
+#include <StepDimTol_GeneralDatumReference.hxx>
+#include <StepDimTol_GeometricTolerance.hxx>
+
+//=======================================================================
+//function : StepDimTol_ToleranceZoneTarget
+//purpose :
+//=======================================================================
+
+StepDimTol_ToleranceZoneTarget::StepDimTol_ToleranceZoneTarget () { }
+
+//=======================================================================
+//function : CaseNum
+//purpose :
+//=======================================================================
+
+Standard_Integer StepDimTol_ToleranceZoneTarget::CaseNum(const Handle(Standard_Transient)& ent) const
+{
+ if (ent.IsNull()) return 0;
+ if (ent->IsKind(STANDARD_TYPE(StepShape_DimensionalLocation))) return 1;
+ if (ent->IsKind(STANDARD_TYPE(StepShape_DimensionalSize))) return 2;
+ if (ent->IsKind(STANDARD_TYPE(StepDimTol_GeometricTolerance))) return 3;
+ if (ent->IsKind(STANDARD_TYPE(StepDimTol_GeneralDatumReference))) return 4;
+ return 0;
+}
+
+Handle(StepShape_DimensionalLocation) StepDimTol_ToleranceZoneTarget::DimensionalLocation() const
+{ return GetCasted(StepShape_DimensionalLocation,Value()); }
+
+Handle(StepShape_DimensionalSize) StepDimTol_ToleranceZoneTarget::DimensionalSize() const
+{ return GetCasted(StepShape_DimensionalSize,Value()); }
+
+Handle(StepDimTol_GeometricTolerance) StepDimTol_ToleranceZoneTarget::GeometricTolerance() const
+{ return GetCasted(StepDimTol_GeometricTolerance,Value()); }
+
+Handle(StepDimTol_GeneralDatumReference) StepDimTol_ToleranceZoneTarget::GeneralDatumReference() const
+{ return GetCasted(StepDimTol_GeneralDatumReference,Value()); }
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_ToleranceZoneTarget_HeaderFile
+#define _StepDimTol_ToleranceZoneTarget_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <StepData_SelectType.hxx>
+#include <Standard_Integer.hxx>
+
+class Standard_Transient;
+class StepDimTol_GeometricTolerance;
+class StepDimTol_GeneralDatumReference;
+class StepShape_DimensionalLocation;
+class StepShape_DimensionalSize;
+
+class StepDimTol_ToleranceZoneTarget : public StepData_SelectType
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ //! Returns a ToleranceZoneTarget select type
+ Standard_EXPORT StepDimTol_ToleranceZoneTarget();
+
+ //! Recognizes a ToleranceZoneTarget Kind Entity that is :
+ //! 1 -> DimensionalLocation
+ //! 2 -> DimensionalSize
+ //! 3 -> GeometricTolerance
+ //! 4 -> GeneralDatumReference
+ //! 0 else
+ Standard_EXPORT Standard_Integer CaseNum (const Handle(Standard_Transient)& ent) const;
+
+ //! returns Value as a DimensionalLocation (Null if another type)
+ Standard_EXPORT Handle(StepShape_DimensionalLocation) DimensionalLocation() const;
+
+ //! returns Value as a DimensionalSize (Null if another type)
+ Standard_EXPORT Handle(StepShape_DimensionalSize) DimensionalSize() const;
+
+ //! returns Value as a GeometricTolerance (Null if another type)
+ Standard_EXPORT Handle(StepDimTol_GeometricTolerance) GeometricTolerance() const;
+
+ //! returns Value as a GeneralDatumReference (Null if another type)
+ Standard_EXPORT Handle(StepDimTol_GeneralDatumReference) GeneralDatumReference() const;
+};
+#endif // _StepDimTol_ToleranceZoneTarget_HeaderFile
--- /dev/null
+// Created on: 2015-07-07
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepDimTol_UnequallyDisposedGeometricTolerance.hxx>
+
+#include <StepDimTol_GeometricToleranceTarget.hxx>
+#include <StepBasic_LengthMeasureWithUnit.hxx>
+
+//=======================================================================
+//function : StepDimTol_UnequallyDisposedGeometricTolerance
+//purpose :
+//=======================================================================
+
+StepDimTol_UnequallyDisposedGeometricTolerance::StepDimTol_UnequallyDisposedGeometricTolerance ()
+{
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepDimTol_UnequallyDisposedGeometricTolerance::Init (const Handle(TCollection_HAsciiString) &theName,
+ const Handle(TCollection_HAsciiString) &theDescription,
+ const Handle(StepBasic_MeasureWithUnit) &theMagnitude,
+ const StepDimTol_GeometricToleranceTarget &theTolerancedShapeAspect,
+ const Handle(StepBasic_LengthMeasureWithUnit) &theDisplacement)
+{
+ StepDimTol_GeometricTolerance::Init( theName, theDescription, theMagnitude, theTolerancedShapeAspect);
+ displacement = theDisplacement;
+}
--- /dev/null
+// Created on: 2015-07-07
+// Created by: Irina KRYLOVA
+// 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 _StepDimTol_UnequallyDisposedGeometricTolerance_HeaderFile
+#define _StepDimTol_UnequallyDisposedGeometricTolerance_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepBasic_LengthMeasureWithUnit.hxx>
+#include <StepDimTol_GeometricTolerance.hxx>
+
+class TCollection_HAsciiString;
+class StepBasic_MeasureWithUnit;
+class StepDimTol_GeometricToleranceTarget;
+
+class StepDimTol_UnequallyDisposedGeometricTolerance;
+DEFINE_STANDARD_HANDLE(StepDimTol_UnequallyDisposedGeometricTolerance, StepDimTol_GeometricTolerance)
+//! Representation of STEP entity UnequallyDisposedGeometricTolerance
+class StepDimTol_UnequallyDisposedGeometricTolerance : public StepDimTol_GeometricTolerance
+{
+
+public:
+
+ //! Empty constructor
+ Standard_EXPORT StepDimTol_UnequallyDisposedGeometricTolerance();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& theName, const Handle(TCollection_HAsciiString)& theDescription, const Handle(StepBasic_MeasureWithUnit)& theMagnitude, const StepDimTol_GeometricToleranceTarget& theTolerancedShapeAspect, const Handle(StepBasic_LengthMeasureWithUnit)& theDisplacement) ;
+
+ //! Returns field Displacement
+ inline Handle(StepBasic_LengthMeasureWithUnit) Displacement () const
+ {
+ return displacement;
+ }
+
+ //! Set field Displacement
+ inline void SetDisplacement (const Handle(StepBasic_LengthMeasureWithUnit) &theDisplacement)
+ {
+ displacement = theDisplacement;
+ }
+
+ DEFINE_STANDARD_RTTI(StepDimTol_UnequallyDisposedGeometricTolerance, StepDimTol_GeometricTolerance)
+
+private:
+ Handle(StepBasic_LengthMeasureWithUnit) displacement;
+};
+#endif // _StepDimTol_UnequallyDisposedGeometricTolerance_HeaderFile
+StepRepr_AllAroundShapeAspect.cxx
+StepRepr_AllAroundShapeAspect.hxx
+StepRepr_Apex.cxx
+StepRepr_Apex.hxx
StepRepr_Array1OfMaterialPropertyRepresentation.hxx
StepRepr_Array1OfPropertyDefinitionRepresentation.hxx
StepRepr_Array1OfRepresentationItem.hxx
+StepRepr_Array1OfShapeAspect.hxx
StepRepr_AssemblyComponentUsage.cxx
StepRepr_AssemblyComponentUsage.hxx
StepRepr_AssemblyComponentUsageSubstitute.cxx
StepRepr_AssemblyComponentUsageSubstitute.hxx
+StepRepr_BetweenShapeAspect.cxx
+StepRepr_BetweenShapeAspect.hxx
+StepRepr_CentreOfSymmetry.cxx
+StepRepr_CentreOfSymmetry.hxx
StepRepr_CharacterizedDefinition.cxx
StepRepr_CharacterizedDefinition.hxx
+StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp.cxx
+StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp.hxx
+StepRepr_CompositeGroupShapeAspect.cxx
+StepRepr_CompositeGroupShapeAspect.hxx
StepRepr_CompositeShapeAspect.cxx
StepRepr_CompositeShapeAspect.hxx
StepRepr_CompoundRepresentationItem.cxx
StepRepr_CompoundRepresentationItem.hxx
+StepRepr_CompShAspAndDatumFeatAndShAsp.cxx
+StepRepr_CompShAspAndDatumFeatAndShAsp.hxx
StepRepr_ConfigurationDesign.cxx
StepRepr_ConfigurationDesign.hxx
StepRepr_ConfigurationDesignItem.cxx
StepRepr_ConfigurationEffectivity.hxx
StepRepr_ConfigurationItem.cxx
StepRepr_ConfigurationItem.hxx
+StepRepr_ContinuosShapeAspect.cxx
+StepRepr_ContinuosShapeAspect.hxx
StepRepr_DataEnvironment.cxx
StepRepr_DataEnvironment.hxx
StepRepr_DefinitionalRepresentation.cxx
StepRepr_ExternallyDefinedRepresentation.hxx
StepRepr_FunctionallyDefinedTransformation.cxx
StepRepr_FunctionallyDefinedTransformation.hxx
+StepRepr_GeometricAlignment.cxx
+StepRepr_GeometricAlignment.hxx
StepRepr_GlobalUncertaintyAssignedContext.cxx
StepRepr_GlobalUncertaintyAssignedContext.hxx
StepRepr_GlobalUnitAssignedContext.cxx
StepRepr_HArray1OfMaterialPropertyRepresentation.hxx
StepRepr_HArray1OfPropertyDefinitionRepresentation.hxx
StepRepr_HArray1OfRepresentationItem.hxx
+StepRepr_HArray1OfShapeAspect.hxx
StepRepr_HSequenceOfMaterialPropertyRepresentation.hxx
StepRepr_HSequenceOfRepresentationItem.hxx
+StepRepr_IntegerRepresentationItem.cxx
+StepRepr_IntegerRepresentationItem.hxx
StepRepr_ItemDefinedTransformation.cxx
StepRepr_ItemDefinedTransformation.hxx
StepRepr_MakeFromUsageOption.cxx
StepRepr_MeasureRepresentationItem.hxx
StepRepr_NextAssemblyUsageOccurrence.cxx
StepRepr_NextAssemblyUsageOccurrence.hxx
+StepRepr_ParallelOffset.cxx
+StepRepr_ParallelOffset.hxx
StepRepr_ParametricRepresentationContext.cxx
StepRepr_ParametricRepresentationContext.hxx
+StepRepr_PerpendicularTo.cxx
+StepRepr_PerpendicularTo.hxx
StepRepr_ProductConcept.cxx
StepRepr_ProductConcept.hxx
StepRepr_ProductDefinitionShape.cxx
StepRepr_RepresentedDefinition.hxx
StepRepr_ReprItemAndLengthMeasureWithUnit.cxx
StepRepr_ReprItemAndLengthMeasureWithUnit.hxx
+StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI.cxx
+StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI.hxx
+StepRepr_ReprItemAndMeasureWithUnit.cxx
+StepRepr_ReprItemAndMeasureWithUnit.hxx
+StepRepr_ReprItemAndMeasureWithUnitAndQRI.cxx
+StepRepr_ReprItemAndMeasureWithUnitAndQRI.hxx
+StepRepr_ReprItemAndPlaneAngleMeasureWithUnit.cxx
+StepRepr_ReprItemAndPlaneAngleMeasureWithUnit.hxx
+StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI.cxx
+StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI.hxx
StepRepr_SequenceOfMaterialPropertyRepresentation.hxx
StepRepr_SequenceOfRepresentationItem.hxx
StepRepr_ShapeAspect.cxx
StepRepr_StructuralResponsePropertyDefinitionRepresentation.hxx
StepRepr_SuppliedPartRelationship.cxx
StepRepr_SuppliedPartRelationship.hxx
+StepRepr_Tangent.cxx
+StepRepr_Tangent.hxx
StepRepr_Transformation.cxx
StepRepr_Transformation.hxx
StepRepr_ValueRange.cxx
StepRepr_ValueRange.hxx
+StepRepr_ValueRepresentationItem.cxx
+StepRepr_ValueRepresentationItem.hxx
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepRepr_AllAroundShapeAspect.hxx>
+
+StepRepr_AllAroundShapeAspect::StepRepr_AllAroundShapeAspect () { }
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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 _StepRepr_AllAroundShapeAspect_HeaderFile
+#define _StepRepr_AllAroundShapeAspect_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepRepr_ContinuosShapeAspect.hxx>
+
+class StepRepr_AllAroundShapeAspect;
+DEFINE_STANDARD_HANDLE(StepRepr_AllAroundShapeAspect, StepRepr_ContinuosShapeAspect)
+//! Added for Dimensional Tolerances
+class StepRepr_AllAroundShapeAspect : public StepRepr_ContinuosShapeAspect
+{
+
+public:
+
+ Standard_EXPORT StepRepr_AllAroundShapeAspect();
+
+ DEFINE_STANDARD_RTTI(StepRepr_AllAroundShapeAspect, StepRepr_ContinuosShapeAspect)
+};
+#endif // _StepRepr_AllAroundShapeAspect_HeaderFile
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepRepr_Apex.hxx>
+
+StepRepr_Apex::StepRepr_Apex () { }
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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 _StepRepr_Apex_HeaderFile
+#define _StepRepr_Apex_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepRepr_DerivedShapeAspect.hxx>
+
+class StepRepr_Apex;
+DEFINE_STANDARD_HANDLE(StepRepr_Apex, StepRepr_DerivedShapeAspect)
+//! Added for Dimensional Tolerances
+class StepRepr_Apex : public StepRepr_DerivedShapeAspect
+{
+
+public:
+
+ Standard_EXPORT StepRepr_Apex();
+
+ DEFINE_STANDARD_RTTI(StepRepr_Apex, StepRepr_DerivedShapeAspect)
+
+};
+#endif // _StepRepr_Apex_HeaderFile
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepRepr_Array1OfShapeAspect.hxx>
+
+#include <Standard_RangeError.hxx>
+#include <Standard_DimensionMismatch.hxx>
+#include <Standard_OutOfRange.hxx>
+#include <Standard_OutOfMemory.hxx>
+
+
+#define Array1Item Handle(StepRepr_ShapeAspect)
+#define Array1Item_hxx <StepRepr_ShapeAspect.hxx>
+#define TCollection_Array1 StepRepr_Array1OfShapeAspect
+#define TCollection_Array1_hxx <StepRepr_Array1OfShapeAspect.hxx>
+#include <TCollection_Array1.gxx>
+
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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 _StepRepr_Array1OfShapeAspect_HeaderFile
+#define _StepRepr_Array1OfShapeAspect_HeaderFile
+
+#include <StepRepr_ShapeAspect.hxx>
+#include <NCollection_Array1.hxx>
+
+typedef NCollection_Array1<Handle(StepRepr_ShapeAspect)> StepRepr_Array1OfShapeAspect;
+
+#endif // _StepRepr_Array1OfShapeAspect_HeaderFile
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepRepr_BetweenShapeAspect.hxx>
+
+StepRepr_BetweenShapeAspect::StepRepr_BetweenShapeAspect () { }
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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 _StepRepr_BetweenShapeAspect_HeaderFile
+#define _StepRepr_BetweenShapeAspect_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepRepr_ContinuosShapeAspect.hxx>
+
+class StepRepr_BetweenShapeAspect;
+DEFINE_STANDARD_HANDLE(StepRepr_BetweenShapeAspect, StepRepr_ContinuosShapeAspect)
+//! Added for Dimensional Tolerances
+class StepRepr_BetweenShapeAspect : public StepRepr_ContinuosShapeAspect
+{
+
+public:
+
+ Standard_EXPORT StepRepr_BetweenShapeAspect();
+
+ DEFINE_STANDARD_RTTI(StepRepr_BetweenShapeAspect, StepRepr_ContinuosShapeAspect)
+
+};
+#endif // _StepRepr_BetweenShapeAspect_HeaderFile
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepRepr_CentreOfSymmetry.hxx>
+
+StepRepr_CentreOfSymmetry::StepRepr_CentreOfSymmetry () { }
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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 _StepRepr_CentreOfSymmetry_HeaderFile
+#define _StepRepr_CentreOfSymmetry_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepRepr_DerivedShapeAspect.hxx>
+
+class StepRepr_CentreOfSymmetry;
+DEFINE_STANDARD_HANDLE(StepRepr_CentreOfSymmetry, StepRepr_DerivedShapeAspect)
+//! Added for Dimensional Tolerances
+class StepRepr_CentreOfSymmetry : public StepRepr_DerivedShapeAspect
+{
+
+public:
+
+ Standard_EXPORT StepRepr_CentreOfSymmetry();
+
+ DEFINE_STANDARD_RTTI(StepRepr_CentreOfSymmetry, StepRepr_DerivedShapeAspect)
+
+};
+#endif // _StepRepr_CentreOfSymmetry_HeaderFile
--- /dev/null
+// Created on: 2015-08-11
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp.hxx>
+
+StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp::StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp () { }
--- /dev/null
+// Created on: 2015-08-11
+// Created by: Irina KRYLOVA
+// 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 _StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp_HeaderFile
+#define _StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepRepr_CompShAspAndDatumFeatAndShAsp.hxx>
+
+class StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp;
+DEFINE_STANDARD_HANDLE(StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp, StepRepr_CompShAspAndDatumFeatAndShAsp)
+//! Added for Dimensional Tolerances
+class StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp : public StepRepr_CompShAspAndDatumFeatAndShAsp
+{
+
+public:
+
+ Standard_EXPORT StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp();
+
+ DEFINE_STANDARD_RTTI(StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp, StepRepr_CompShAspAndDatumFeatAndShAsp)
+};
+#endif // _StepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp_HeaderFile
--- /dev/null
+// Created on: 2015-08-11
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepRepr_CompShAspAndDatumFeatAndShAsp.hxx>
+
+StepRepr_CompShAspAndDatumFeatAndShAsp::StepRepr_CompShAspAndDatumFeatAndShAsp () { }
--- /dev/null
+// Created on: 2015-08-11
+// Created by: Irina KRYLOVA
+// 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 _StepRepr_CompShAspAndDatumFeatAndShAsp_HeaderFile
+#define _StepRepr_CompShAspAndDatumFeatAndShAsp_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepRepr_ShapeAspect.hxx>
+
+class StepRepr_CompShAspAndDatumFeatAndShAsp;
+DEFINE_STANDARD_HANDLE(StepRepr_CompShAspAndDatumFeatAndShAsp, StepRepr_ShapeAspect)
+//! Added for Dimensional Tolerances
+class StepRepr_CompShAspAndDatumFeatAndShAsp : public StepRepr_ShapeAspect
+{
+
+public:
+
+ Standard_EXPORT StepRepr_CompShAspAndDatumFeatAndShAsp();
+
+ DEFINE_STANDARD_RTTI(StepRepr_CompShAspAndDatumFeatAndShAsp, StepRepr_ShapeAspect)
+};
+#endif // _StepRepr_CompShAspAndDatumFeatAndShAsp_HeaderFile
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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.
+#include <StepRepr_CompositeGroupShapeAspect.hxx>
+
+StepRepr_CompositeGroupShapeAspect::StepRepr_CompositeGroupShapeAspect () { }
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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 _StepRepr_CompositeGroupShapeAspect_HeaderFile
+#define _StepRepr_CompositeGroupShapeAspect_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepRepr_CompositeShapeAspect.hxx>
+
+class StepRepr_CompositeGroupShapeAspect;
+DEFINE_STANDARD_HANDLE(StepRepr_CompositeGroupShapeAspect, StepRepr_CompositeShapeAspect)
+//! Added for Dimensional Tolerances
+class StepRepr_CompositeGroupShapeAspect : public StepRepr_CompositeShapeAspect
+{
+
+public:
+
+ Standard_EXPORT StepRepr_CompositeGroupShapeAspect();
+
+ DEFINE_STANDARD_RTTI(StepRepr_CompositeGroupShapeAspect, StepRepr_CompositeShapeAspect)
+
+};
+#endif // _StepRepr_CompositeGroupShapeAspect_HeaderFile
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepRepr_ContinuosShapeAspect.hxx>
+
+StepRepr_ContinuosShapeAspect::StepRepr_ContinuosShapeAspect () { }
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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 _StepRepr_ContinuosShapeAspect_HeaderFile
+#define _StepRepr_ContinuosShapeAspect_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepRepr_CompositeShapeAspect.hxx>
+
+class StepRepr_ContinuosShapeAspect;
+DEFINE_STANDARD_HANDLE(StepRepr_ContinuosShapeAspect, StepRepr_CompositeShapeAspect)
+//! Added for Dimensional Tolerances
+class StepRepr_ContinuosShapeAspect : public StepRepr_CompositeShapeAspect
+{
+
+public:
+
+ Standard_EXPORT StepRepr_ContinuosShapeAspect();
+
+ DEFINE_STANDARD_RTTI(StepRepr_ContinuosShapeAspect, StepRepr_CompositeShapeAspect)
+};
+#endif // _StepRepr_ContinuosShapeAspect_HeaderFile
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepRepr_GeometricAlignment.hxx>
+
+StepRepr_GeometricAlignment::StepRepr_GeometricAlignment () { }
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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 _StepRepr_GeometricAlignment_HeaderFile
+#define _StepRepr_GeometricAlignment_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepRepr_DerivedShapeAspect.hxx>
+
+class StepRepr_GeometricAlignment;
+DEFINE_STANDARD_HANDLE(StepRepr_GeometricAlignment, StepRepr_DerivedShapeAspect)
+//! Added for Dimensional Tolerances
+class StepRepr_GeometricAlignment : public StepRepr_DerivedShapeAspect
+{
+
+public:
+
+ Standard_EXPORT StepRepr_GeometricAlignment();
+
+ DEFINE_STANDARD_RTTI(StepRepr_GeometricAlignment, StepRepr_DerivedShapeAspect)
+};
+#endif // _StepRepr_GeometricAlignment_HeaderFile
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepRepr_HArray1OfShapeAspect.hxx>
+
+#include <Standard_Type.hxx>
+
+#include <Standard_RangeError.hxx>
+#include <Standard_DimensionMismatch.hxx>
+#include <Standard_OutOfRange.hxx>
+#include <Standard_OutOfMemory.hxx>
+#include <StepRepr_Array1OfShapeAspect.hxx>
+#include <StepRepr_ShapeAspect.hxx>
+
+IMPLEMENT_STANDARD_TYPE(StepRepr_HArray1OfShapeAspect)
+ IMPLEMENT_STANDARD_SUPERTYPE_ARRAY()
+ STANDARD_TYPE(MMgt_TShared),
+ STANDARD_TYPE(Standard_Transient),
+ IMPLEMENT_STANDARD_SUPERTYPE_ARRAY_END()
+IMPLEMENT_STANDARD_TYPE_END(StepRepr_HArray1OfShapeAspect)
+
+
+IMPLEMENT_DOWNCAST(StepRepr_HArray1OfShapeAspect,Standard_Transient)
+IMPLEMENT_STANDARD_RTTI(StepRepr_HArray1OfShapeAspect)
+
+#define ItemHArray1 Handle(StepRepr_ShapeAspect)
+#define ItemHArray1_hxx <StepRepr_ShapeAspect.hxx>
+#define TheArray1 StepRepr_Array1OfShapeAspect
+#define TheArray1_hxx <StepRepr_Array1OfShapeAspect.hxx>
+#define TCollection_HArray1 StepRepr_HArray1OfShapeAspect
+#define TCollection_HArray1_hxx <StepRepr_HArray1OfShapeAspect.hxx>
+#define Handle_TCollection_HArray1 Handle_StepRepr_HArray1OfShapeAspect
+#define TCollection_HArray1_Type_() StepRepr_HArray1OfShapeAspect_Type_()
+#include <TCollection_HArray1.gxx>
--- /dev/null
+// Created on: 2015-07-13
+// Created by: Irina KRYLOVA
+// 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 _StepRepr_HArray1OfShapeAspect_HeaderFile
+#define _StepRepr_HArray1OfShapeAspect_HeaderFile
+
+#include <StepRepr_ShapeAspect.hxx>
+#include <StepRepr_Array1OfShapeAspect.hxx>
+#include <NCollection_DefineHArray1.hxx>
+
+DEFINE_HARRAY1(StepRepr_HArray1OfShapeAspect, StepRepr_Array1OfShapeAspect)
+#endif // _StepRepr_HArray1OfShapeAspect_HeaderFile
--- /dev/null
+// Created on: 2015-09-03
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <Standard_Type.hxx>
+#include <StepRepr_IntegerRepresentationItem.hxx>
+#include <TCollection_HAsciiString.hxx>
+
+StepRepr_IntegerRepresentationItem::StepRepr_IntegerRepresentationItem () {}
+
+void StepRepr_IntegerRepresentationItem::Init(
+ const Handle(TCollection_HAsciiString)& theName,
+ const Standard_Integer theValue)
+{
+ value = theValue;
+ StepRepr_RepresentationItem::Init(theName);
+}
--- /dev/null
+// Created on: 2015-09-03
+// Created by: Irina KRYLOVA
+// 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 _StepRepr_IntegerRepresentationItem_HeaderFile
+#define _StepRepr_IntegerRepresentationItem_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepRepr_RepresentationItem.hxx>
+class TCollection_HAsciiString;
+
+
+class StepRepr_IntegerRepresentationItem;
+DEFINE_STANDARD_HANDLE(StepRepr_IntegerRepresentationItem, StepRepr_RepresentationItem)
+
+
+class StepRepr_IntegerRepresentationItem : public StepRepr_RepresentationItem
+{
+
+public:
+
+
+ //! Returns a IntegerRepresentationItem
+ Standard_EXPORT StepRepr_IntegerRepresentationItem();
+
+ Standard_EXPORT virtual void Init (const Handle(TCollection_HAsciiString)& theName, const Standard_Integer theValue);
+
+ inline void SetValue(const Standard_Integer theValue)
+ {
+ value = theValue;
+ }
+
+ inline Standard_Integer Value() const
+ {
+ return value;
+ }
+
+ DEFINE_STANDARD_RTTI(StepRepr_IntegerRepresentationItem,StepRepr_RepresentationItem)
+
+private:
+ Standard_Integer value;
+};
+#endif // _StepRepr_IntegerRepresentationItem_HeaderFile
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepRepr_ParallelOffset.hxx>
+
+StepRepr_ParallelOffset::StepRepr_ParallelOffset () { }
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepRepr_ParallelOffset::Init(
+ const Handle(TCollection_HAsciiString)& theShapeAspect_Name,
+ const Handle(TCollection_HAsciiString)& theShapeAspect_Description,
+ const Handle(StepRepr_ProductDefinitionShape)& theShapeAspect_OfShape,
+ const StepData_Logical theShapeAspect_ProductDefinitional,
+ const Handle(StepBasic_MeasureWithUnit) &theOffset)
+{
+ StepRepr_ShapeAspect::Init(theShapeAspect_Name,
+ theShapeAspect_Description,
+ theShapeAspect_OfShape,
+ theShapeAspect_ProductDefinitional);
+
+ offset = theOffset;
+}
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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 _StepRepr_ParallelOffset_HeaderFile
+#define _StepRepr_ParallelOffset_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepRepr_DerivedShapeAspect.hxx>
+#include <StepData_Logical.hxx>
+class StepBasic_MeasureWithUnit;
+class TCollection_HAsciiString;
+class StepRepr_ProductDefinitionShape;
+
+class StepRepr_ParallelOffset;
+DEFINE_STANDARD_HANDLE(StepRepr_ParallelOffset, StepRepr_DerivedShapeAspect)
+//! Added for Dimensional Tolerances
+class StepRepr_ParallelOffset : public StepRepr_DerivedShapeAspect
+{
+
+public:
+
+ Standard_EXPORT StepRepr_ParallelOffset();
+
+ //! Initialize all fields (own and inherited)
+ Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& theName, const Handle(TCollection_HAsciiString)& theDescription, const Handle(StepRepr_ProductDefinitionShape)& theOfShape, const StepData_Logical theProductDefinitional, const Handle(StepBasic_MeasureWithUnit)& theOffset) ;
+
+ //! Returns field Offset
+ inline Handle(StepBasic_MeasureWithUnit) Offset () const
+ {
+ return offset;
+ }
+
+ //! Set field Offset
+ inline void SetOffset (const Handle(StepBasic_MeasureWithUnit)& theOffset)
+ {
+ offset = theOffset;
+ }
+
+ DEFINE_STANDARD_RTTI(StepRepr_ParallelOffset, StepRepr_DerivedShapeAspect)
+
+private:
+ Handle(StepBasic_MeasureWithUnit) offset;
+};
+#endif // _StepRepr_ParallelOffset_HeaderFile
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepRepr_PerpendicularTo.hxx>
+
+StepRepr_PerpendicularTo::StepRepr_PerpendicularTo () { }
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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 _StepRepr_PerpendicularTo_HeaderFile
+#define _StepRepr_PerpendicularTo_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <StepRepr_DerivedShapeAspect.hxx>
+
+class StepRepr_PerpendicularTo;
+DEFINE_STANDARD_HANDLE(StepRepr_PerpendicularTo, StepRepr_DerivedShapeAspect)
+//! Added for Dimensional Tolerances
+class StepRepr_PerpendicularTo : public StepRepr_DerivedShapeAspect
+{
+
+public:
+
+ Standard_EXPORT StepRepr_PerpendicularTo();
+
+ DEFINE_STANDARD_RTTI(StepRepr_PerpendicularTo, StepRepr_DerivedShapeAspect)
+};
+#endif // _StepRepr_PerpendicularTo_HeaderFile
#include <Standard_Type.hxx>
#include <StepBasic_LengthMeasureWithUnit.hxx>
-#include <StepBasic_MeasureWithUnit.hxx>
-#include <StepRepr_MeasureRepresentationItem.hxx>
-#include <StepRepr_RepresentationItem.hxx>
#include <StepRepr_ReprItemAndLengthMeasureWithUnit.hxx>
//=======================================================================
//function : StepRepr_ReprItemAndLengthMeasureWithUnit
//purpose :
//=======================================================================
-StepRepr_ReprItemAndLengthMeasureWithUnit::StepRepr_ReprItemAndLengthMeasureWithUnit()
+StepRepr_ReprItemAndLengthMeasureWithUnit::StepRepr_ReprItemAndLengthMeasureWithUnit() : StepRepr_ReprItemAndMeasureWithUnit()
{
myLengthMeasureWithUnit = new StepBasic_LengthMeasureWithUnit();
- myMeasureWithUnit = new StepBasic_MeasureWithUnit();
- myMeasureRepresentationItem = new StepRepr_MeasureRepresentationItem();
}
-
-//=======================================================================
-//function : Init
-//purpose :
-//=======================================================================
-
-void StepRepr_ReprItemAndLengthMeasureWithUnit::Init
- (const Handle(StepBasic_MeasureWithUnit)& aMWU,
- const Handle(StepRepr_RepresentationItem)& aRI)
-{
- myMeasureWithUnit = aMWU;
- SetName(aRI->Name());
-}
-
-
//=======================================================================
//function : SetLengthMeasureWithUnit
//purpose :
{
return myLengthMeasureWithUnit;
}
-
-
-//=======================================================================
-//function : GetMeasureRepresentationItem
-//purpose :
-//=======================================================================
-
-Handle(StepRepr_MeasureRepresentationItem) StepRepr_ReprItemAndLengthMeasureWithUnit::
- GetMeasureRepresentationItem() const
-{
- return myMeasureRepresentationItem;
-}
-
-
-//=======================================================================
-//function : SetMeasureWithUnit
-//purpose :
-//=======================================================================
-
-void StepRepr_ReprItemAndLengthMeasureWithUnit::SetMeasureWithUnit
- (const Handle(StepBasic_MeasureWithUnit)& aMWU)
-{
- myMeasureWithUnit = aMWU;
-}
-
-
-//=======================================================================
-//function : GetMeasureWithUnit
-//purpose :
-//=======================================================================
-
-Handle(StepBasic_MeasureWithUnit) StepRepr_ReprItemAndLengthMeasureWithUnit::
- GetMeasureWithUnit() const
-{
- return myMeasureWithUnit;
-}
-
-
-//=======================================================================
-//function : GetRepresentationItem
-//purpose :
-//=======================================================================
-
-Handle(StepRepr_RepresentationItem) StepRepr_ReprItemAndLengthMeasureWithUnit::
- GetRepresentationItem() const
-{
- Handle(StepRepr_RepresentationItem) RI = new StepRepr_RepresentationItem();
- RI->Init(Name());
- return RI;
-}
-
-
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ReprItemAndMeasureWithUnit.hxx>
class StepBasic_LengthMeasureWithUnit;
-class StepRepr_MeasureRepresentationItem;
-class StepBasic_MeasureWithUnit;
-class StepRepr_RepresentationItem;
class StepRepr_ReprItemAndLengthMeasureWithUnit;
-DEFINE_STANDARD_HANDLE(StepRepr_ReprItemAndLengthMeasureWithUnit, StepRepr_RepresentationItem)
+DEFINE_STANDARD_HANDLE(StepRepr_ReprItemAndLengthMeasureWithUnit, StepRepr_ReprItemAndMeasureWithUnit)
-class StepRepr_ReprItemAndLengthMeasureWithUnit : public StepRepr_RepresentationItem
+class StepRepr_ReprItemAndLengthMeasureWithUnit : public StepRepr_ReprItemAndMeasureWithUnit
{
public:
Standard_EXPORT StepRepr_ReprItemAndLengthMeasureWithUnit();
- Standard_EXPORT void Init (const Handle(StepBasic_MeasureWithUnit)& aMWU, const Handle(StepRepr_RepresentationItem)& aRI);
-
Standard_EXPORT void SetLengthMeasureWithUnit (const Handle(StepBasic_LengthMeasureWithUnit)& aLMWU);
Standard_EXPORT Handle(StepBasic_LengthMeasureWithUnit) GetLengthMeasureWithUnit() const;
-
- Standard_EXPORT Handle(StepRepr_MeasureRepresentationItem) GetMeasureRepresentationItem() const;
-
- Standard_EXPORT void SetMeasureWithUnit (const Handle(StepBasic_MeasureWithUnit)& aMWU);
-
- Standard_EXPORT Handle(StepBasic_MeasureWithUnit) GetMeasureWithUnit() const;
-
- Standard_EXPORT Handle(StepRepr_RepresentationItem) GetRepresentationItem() const;
-
-
-
-
- DEFINE_STANDARD_RTTI(StepRepr_ReprItemAndLengthMeasureWithUnit,StepRepr_RepresentationItem)
-
-protected:
-
-
+ DEFINE_STANDARD_RTTI(StepRepr_ReprItemAndLengthMeasureWithUnit,StepRepr_ReprItemAndMeasureWithUnit)
private:
-
-
Handle(StepBasic_LengthMeasureWithUnit) myLengthMeasureWithUnit;
- Handle(StepRepr_MeasureRepresentationItem) myMeasureRepresentationItem;
- Handle(StepBasic_MeasureWithUnit) myMeasureWithUnit;
-
-
};
-
-
-
-
-
-
-
#endif // _StepRepr_ReprItemAndLengthMeasureWithUnit_HeaderFile
--- /dev/null
+// Copyright (c) 1999-2014 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 <Standard_Type.hxx>
+#include <StepBasic_LengthMeasureWithUnit.hxx>
+#include <StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI.hxx>
+
+//=======================================================================
+//function : StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI
+//purpose :
+//=======================================================================
+StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI::StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI() : StepRepr_ReprItemAndMeasureWithUnitAndQRI()
+{
+ myLengthMeasureWithUnit = new StepBasic_LengthMeasureWithUnit();
+}
+
+//=======================================================================
+//function : SetLengthMeasureWithUnit
+//purpose :
+//=======================================================================
+
+void StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI::SetLengthMeasureWithUnit
+ (const Handle(StepBasic_LengthMeasureWithUnit)& aLMWU)
+{
+ myLengthMeasureWithUnit = aLMWU;
+}
+
+
+//=======================================================================
+//function : GetLengthMeasureWithUnit
+//purpose :
+//=======================================================================
+
+Handle(StepBasic_LengthMeasureWithUnit) StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI::
+ GetLengthMeasureWithUnit() const
+{
+ return myLengthMeasureWithUnit;
+}
--- /dev/null
+// Created on: 2003-08-21
+// Created by: Sergey KUUL
+// Copyright (c) 2003-2014 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 _StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI_HeaderFile
+#define _StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepRepr_ReprItemAndMeasureWithUnitAndQRI.hxx>
+class StepBasic_LengthMeasureWithUnit;
+
+
+class StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI;
+DEFINE_STANDARD_HANDLE(StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI, StepRepr_ReprItemAndMeasureWithUnitAndQRI)
+
+
+class StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI : public StepRepr_ReprItemAndMeasureWithUnitAndQRI
+{
+
+public:
+
+
+ Standard_EXPORT StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI();
+
+ Standard_EXPORT void SetLengthMeasureWithUnit (const Handle(StepBasic_LengthMeasureWithUnit)& aLMWU);
+
+ Standard_EXPORT Handle(StepBasic_LengthMeasureWithUnit) GetLengthMeasureWithUnit() const;
+
+ DEFINE_STANDARD_RTTI(StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI,StepRepr_ReprItemAndMeasureWithUnitAndQRI)
+
+private:
+ Handle(StepBasic_LengthMeasureWithUnit) myLengthMeasureWithUnit;
+};
+#endif // _StepRepr_ReprItemAndLengthMeasureWithUnitAndQRI_HeaderFile
--- /dev/null
+// Created on: 2015-07-22
+// Created by: Irina KRYLOVA
+// 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.
+
+
+#include <Standard_Type.hxx>
+#include <StepBasic_MeasureWithUnit.hxx>
+#include <StepRepr_MeasureRepresentationItem.hxx>
+#include <StepRepr_RepresentationItem.hxx>
+#include <StepRepr_ReprItemAndMeasureWithUnit.hxx>
+
+//=======================================================================
+//function : StepRepr_ReprItemAndMeasureWithUnit
+//purpose :
+//=======================================================================
+StepRepr_ReprItemAndMeasureWithUnit::StepRepr_ReprItemAndMeasureWithUnit()
+{
+ myMeasureWithUnit = new StepBasic_MeasureWithUnit();
+ myMeasureRepresentationItem = new StepRepr_MeasureRepresentationItem();
+}
+
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepRepr_ReprItemAndMeasureWithUnit::Init
+ (const Handle(StepBasic_MeasureWithUnit)& aMWU,
+ const Handle(StepRepr_RepresentationItem)& aRI)
+{
+ myMeasureWithUnit = aMWU;
+ SetName(aRI->Name());
+}
+
+//=======================================================================
+//function : GetMeasureRepresentationItem
+//purpose :
+//=======================================================================
+
+Handle(StepRepr_MeasureRepresentationItem) StepRepr_ReprItemAndMeasureWithUnit::
+ GetMeasureRepresentationItem() const
+{
+ return myMeasureRepresentationItem;
+}
+
+
+//=======================================================================
+//function : SetMeasureWithUnit
+//purpose :
+//=======================================================================
+
+void StepRepr_ReprItemAndMeasureWithUnit::SetMeasureWithUnit
+ (const Handle(StepBasic_MeasureWithUnit)& aMWU)
+{
+ myMeasureWithUnit = aMWU;
+}
+
+
+//=======================================================================
+//function : GetMeasureWithUnit
+//purpose :
+//=======================================================================
+
+Handle(StepBasic_MeasureWithUnit) StepRepr_ReprItemAndMeasureWithUnit::
+ GetMeasureWithUnit() const
+{
+ return myMeasureWithUnit;
+}
+
+
+//=======================================================================
+//function : GetRepresentationItem
+//purpose :
+//=======================================================================
+
+Handle(StepRepr_RepresentationItem) StepRepr_ReprItemAndMeasureWithUnit::
+ GetRepresentationItem() const
+{
+ Handle(StepRepr_RepresentationItem) RI = new StepRepr_RepresentationItem();
+ RI->Init(Name());
+ return RI;
+}
--- /dev/null
+// Created on: 2015-07-22
+// Created by: Irina KRYLOVA
+// 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 _StepRepr_ReprItemAndMeasureWithUnit_HeaderFile
+#define _StepRepr_ReprItemAndMeasureWithUnit_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepRepr_RepresentationItem.hxx>
+class StepRepr_MeasureRepresentationItem;
+class StepBasic_MeasureWithUnit;
+class StepRepr_RepresentationItem;
+
+
+class StepRepr_ReprItemAndMeasureWithUnit;
+DEFINE_STANDARD_HANDLE(StepRepr_ReprItemAndMeasureWithUnit, StepRepr_RepresentationItem)
+
+//! Base class for complex types (MEASURE_REPRESENTATION_ITEM, MEASURE_WITH_UNIT,
+//! REPRESENTATION_ITEM, LENGTH_MEASURE_WITH_UNIT/PLANE_ANGLE_MEASURE_WITH_UNIT).
+class StepRepr_ReprItemAndMeasureWithUnit : public StepRepr_RepresentationItem
+{
+
+public:
+
+
+ Standard_EXPORT StepRepr_ReprItemAndMeasureWithUnit();
+
+ Standard_EXPORT void Init (const Handle(StepBasic_MeasureWithUnit)& aMWU, const Handle(StepRepr_RepresentationItem)& aRI);
+
+ Standard_EXPORT Handle(StepRepr_MeasureRepresentationItem) GetMeasureRepresentationItem() const;
+
+ Standard_EXPORT void SetMeasureWithUnit (const Handle(StepBasic_MeasureWithUnit)& aMWU);
+
+ Standard_EXPORT Handle(StepBasic_MeasureWithUnit) GetMeasureWithUnit() const;
+
+ Standard_EXPORT Handle(StepRepr_RepresentationItem) GetRepresentationItem() const;
+
+ DEFINE_STANDARD_RTTI(StepRepr_ReprItemAndMeasureWithUnit,StepRepr_RepresentationItem)
+
+private:
+
+ Handle(StepRepr_MeasureRepresentationItem) myMeasureRepresentationItem;
+ Handle(StepBasic_MeasureWithUnit) myMeasureWithUnit;
+};
+#endif // _StepRepr_ReprItemAndMeasureWithUnit_HeaderFile
--- /dev/null
+// Created on: 2015-07-22
+// Created by: Irina KRYLOVA
+// 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.
+
+
+#include <Standard_Type.hxx>
+#include <StepShape_QualifiedRepresentationItem.hxx>
+#include <StepRepr_ReprItemAndMeasureWithUnitAndQRI.hxx>
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepRepr_ReprItemAndMeasureWithUnitAndQRI::Init (const Handle(StepBasic_MeasureWithUnit)& aMWU,
+ const Handle(StepRepr_RepresentationItem)& aRI,
+ const Handle(StepShape_QualifiedRepresentationItem) aQRI)
+{
+ StepRepr_ReprItemAndMeasureWithUnit::Init(aMWU, aRI);
+ myQualifiedRepresentationItem = aQRI;
+}
+
+//=======================================================================
+//function : StepRepr_ReprItemAndMeasureWithUnitAndQRI
+//purpose :
+//=======================================================================
+StepRepr_ReprItemAndMeasureWithUnitAndQRI::StepRepr_ReprItemAndMeasureWithUnitAndQRI() : StepRepr_ReprItemAndMeasureWithUnit()
+{
+ myQualifiedRepresentationItem = new StepShape_QualifiedRepresentationItem();
+}
+
+//=======================================================================
+//function : SetQualifiedRepresentationItem
+//purpose :
+//=======================================================================
+
+void StepRepr_ReprItemAndMeasureWithUnitAndQRI::SetQualifiedRepresentationItem
+ (const Handle(StepShape_QualifiedRepresentationItem)& aQRI)
+{
+ myQualifiedRepresentationItem = aQRI;
+}
+
+
+//=======================================================================
+//function : GetPlaneAngleMeasureWithUnit
+//purpose :
+//=======================================================================
+
+Handle(StepShape_QualifiedRepresentationItem) StepRepr_ReprItemAndMeasureWithUnitAndQRI::
+ GetQualifiedRepresentationItem() const
+{
+ return myQualifiedRepresentationItem;
+}
--- /dev/null
+// Created on: 2015-07-22
+// Created by: Irina KRYLOVA
+// 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 _StepRepr_ReprItemAndMeasureWithUnitAndQRI_HeaderFile
+#define _StepRepr_ReprItemAndMeasureWithUnitAndQRI_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepRepr_ReprItemAndMeasureWithUnit.hxx>
+class StepShape_QualifiedRepresentationItem;
+
+class StepRepr_ReprItemAndMeasureWithUnitAndQRI;
+DEFINE_STANDARD_HANDLE(StepRepr_ReprItemAndMeasureWithUnitAndQRI, StepRepr_ReprItemAndMeasureWithUnit)
+
+//! Base class for complex types (MEASURE_REPRESENTATION_ITEM, MEASURE_WITH_UNIT, QUALIFIED_REPRESENTATION_ITEM
+//! REPRESENTATION_ITEM, LENGTH_MEASURE_WITH_UNIT/PLANE_ANGLE_MEASURE_WITH_UNIT).
+class StepRepr_ReprItemAndMeasureWithUnitAndQRI : public StepRepr_ReprItemAndMeasureWithUnit
+{
+
+public:
+
+
+ Standard_EXPORT StepRepr_ReprItemAndMeasureWithUnitAndQRI();
+
+ Standard_EXPORT void Init (const Handle(StepBasic_MeasureWithUnit)& aMWU, const Handle(StepRepr_RepresentationItem)& aRI, const Handle(StepShape_QualifiedRepresentationItem) aQRI);
+
+ Standard_EXPORT void SetQualifiedRepresentationItem (const Handle(StepShape_QualifiedRepresentationItem)& aQRI);
+
+ Standard_EXPORT Handle(StepShape_QualifiedRepresentationItem) GetQualifiedRepresentationItem() const;
+
+ DEFINE_STANDARD_RTTI(StepRepr_ReprItemAndMeasureWithUnitAndQRI,StepRepr_ReprItemAndMeasureWithUnit)
+
+private:
+ Handle(StepShape_QualifiedRepresentationItem) myQualifiedRepresentationItem;
+};
+#endif // _StepRepr_ReprItemAndMeasureWithUnitAndQRI_HeaderFile
--- /dev/null
+// Created on: 2015-07-22
+// Created by: Irina KRYLOVA
+// 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.
+
+
+#include <Standard_Type.hxx>
+#include <StepBasic_PlaneAngleMeasureWithUnit.hxx>
+#include <StepRepr_ReprItemAndPlaneAngleMeasureWithUnit.hxx>
+
+//=======================================================================
+//function : StepRepr_ReprItemAndPlaneAngleMeasureWithUnit
+//purpose :
+//=======================================================================
+StepRepr_ReprItemAndPlaneAngleMeasureWithUnit::StepRepr_ReprItemAndPlaneAngleMeasureWithUnit() : StepRepr_ReprItemAndMeasureWithUnit()
+{
+ myPlaneAngleMeasureWithUnit = new StepBasic_PlaneAngleMeasureWithUnit();
+}
+
+//=======================================================================
+//function : SetPlaneAngleMeasureWithUnit
+//purpose :
+//=======================================================================
+
+void StepRepr_ReprItemAndPlaneAngleMeasureWithUnit::SetPlaneAngleMeasureWithUnit
+ (const Handle(StepBasic_PlaneAngleMeasureWithUnit)& aLMWU)
+{
+ myPlaneAngleMeasureWithUnit = aLMWU;
+}
+
+
+//=======================================================================
+//function : GetPlaneAngleMeasureWithUnit
+//purpose :
+//=======================================================================
+
+Handle(StepBasic_PlaneAngleMeasureWithUnit) StepRepr_ReprItemAndPlaneAngleMeasureWithUnit::
+ GetPlaneAngleMeasureWithUnit() const
+{
+ return myPlaneAngleMeasureWithUnit;
+}
--- /dev/null
+// Created on: 2015-07-22
+// Created by: Irina KRYLOVA
+// 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 _StepRepr_ReprItemAndPlaneAngleMeasureWithUnit_HeaderFile
+#define _StepRepr_ReprItemAndPlaneAngleMeasureWithUnit_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepRepr_ReprItemAndMeasureWithUnit.hxx>
+class StepBasic_PlaneAngleMeasureWithUnit;
+
+class StepRepr_ReprItemAndPlaneAngleMeasureWithUnit;
+DEFINE_STANDARD_HANDLE(StepRepr_ReprItemAndPlaneAngleMeasureWithUnit, StepRepr_ReprItemAndMeasureWithUnit)
+
+
+class StepRepr_ReprItemAndPlaneAngleMeasureWithUnit : public StepRepr_ReprItemAndMeasureWithUnit
+{
+
+public:
+
+
+ Standard_EXPORT StepRepr_ReprItemAndPlaneAngleMeasureWithUnit();
+
+ Standard_EXPORT void SetPlaneAngleMeasureWithUnit (const Handle(StepBasic_PlaneAngleMeasureWithUnit)& aLMWU);
+
+ Standard_EXPORT Handle(StepBasic_PlaneAngleMeasureWithUnit) GetPlaneAngleMeasureWithUnit() const;
+
+ DEFINE_STANDARD_RTTI(StepRepr_ReprItemAndPlaneAngleMeasureWithUnit,StepRepr_ReprItemAndMeasureWithUnit)
+
+private:
+ Handle(StepBasic_PlaneAngleMeasureWithUnit) myPlaneAngleMeasureWithUnit;
+};
+#endif // _StepRepr_ReprItemAndPlaneAngleMeasureWithUnit_HeaderFile
--- /dev/null
+// Created on: 2015-07-22
+// Created by: Irina KRYLOVA
+// 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.
+
+
+#include <Standard_Type.hxx>
+#include <StepBasic_PlaneAngleMeasureWithUnit.hxx>
+#include <StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI.hxx>
+
+//=======================================================================
+//function : StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI
+//purpose :
+//=======================================================================
+StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI::StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI() : StepRepr_ReprItemAndMeasureWithUnitAndQRI()
+{
+ myPlaneAngleMeasureWithUnit = new StepBasic_PlaneAngleMeasureWithUnit();
+}
+
+//=======================================================================
+//function : SetPlaneAngleMeasureWithUnit
+//purpose :
+//=======================================================================
+
+void StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI::SetPlaneAngleMeasureWithUnit
+ (const Handle(StepBasic_PlaneAngleMeasureWithUnit)& aLMWU)
+{
+ myPlaneAngleMeasureWithUnit = aLMWU;
+}
+
+
+//=======================================================================
+//function : GetPlaneAngleMeasureWithUnit
+//purpose :
+//=======================================================================
+
+Handle(StepBasic_PlaneAngleMeasureWithUnit) StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI::
+ GetPlaneAngleMeasureWithUnit() const
+{
+ return myPlaneAngleMeasureWithUnit;
+}
--- /dev/null
+// Created on: 2015-07-22
+// Created by: Irina KRYLOVA
+// 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 _StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI_HeaderFile
+#define _StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepRepr_ReprItemAndMeasureWithUnitAndQRI.hxx>
+class StepBasic_PlaneAngleMeasureWithUnit;
+
+class StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI;
+DEFINE_STANDARD_HANDLE(StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI, StepRepr_ReprItemAndMeasureWithUnitAndQRI)
+
+
+class StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI : public StepRepr_ReprItemAndMeasureWithUnitAndQRI
+{
+
+public:
+
+
+ Standard_EXPORT StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI();
+
+ Standard_EXPORT void SetPlaneAngleMeasureWithUnit (const Handle(StepBasic_PlaneAngleMeasureWithUnit)& aLMWU);
+
+ Standard_EXPORT Handle(StepBasic_PlaneAngleMeasureWithUnit) GetPlaneAngleMeasureWithUnit() const;
+
+ DEFINE_STANDARD_RTTI(StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI,StepRepr_ReprItemAndMeasureWithUnitAndQRI)
+
+private:
+ Handle(StepBasic_PlaneAngleMeasureWithUnit) myPlaneAngleMeasureWithUnit;
+};
+#endif // _StepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI_HeaderFile
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepRepr_Tangent.hxx>
+
+StepRepr_Tangent::StepRepr_Tangent () { }
--- /dev/null
+// Created on: 2015-07-10
+// Created by: Irina KRYLOVA
+// 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 _StepRepr_Tangent_HeaderFile
+#define _StepRepr_Tangent_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepRepr_DerivedShapeAspect.hxx>
+
+class StepRepr_Tangent;
+DEFINE_STANDARD_HANDLE(StepRepr_Tangent, StepRepr_DerivedShapeAspect)
+//! Added for Dimensional Tolerances
+class StepRepr_Tangent : public StepRepr_DerivedShapeAspect
+{
+
+public:
+
+ Standard_EXPORT StepRepr_Tangent();
+
+ DEFINE_STANDARD_RTTI(StepRepr_Tangent, StepRepr_DerivedShapeAspect)
+
+};
+#endif // _StepRepr_Tangent_HeaderFile
--- /dev/null
+// Created on: 2015-09-09
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <Standard_Type.hxx>
+#include <StepBasic_MeasureValueMember.hxx>
+#include <StepRepr_ValueRepresentationItem.hxx>
+#include <TCollection_HAsciiString.hxx>
+
+StepRepr_ValueRepresentationItem::StepRepr_ValueRepresentationItem () {}
+
+void StepRepr_ValueRepresentationItem::Init(
+ const Handle(TCollection_HAsciiString)& theName,
+ const Handle(StepBasic_MeasureValueMember)& theValueComponentMember)
+{
+ valueComponentMember = theValueComponentMember;
+ StepRepr_RepresentationItem::Init(theName);
+}
--- /dev/null
+// Created on: 2015-09-09
+// Created by: Irina KRYLOVA
+// 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 _StepRepr_ValueRepresentationItem_HeaderFile
+#define _StepRepr_ValueRepresentationItem_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+
+#include <StepRepr_RepresentationItem.hxx>
+class StepBasic_MeasureValueMember;
+class TCollection_HAsciiString;
+
+
+class StepRepr_ValueRepresentationItem;
+DEFINE_STANDARD_HANDLE(StepRepr_ValueRepresentationItem, StepRepr_RepresentationItem)
+
+
+class StepRepr_ValueRepresentationItem : public StepRepr_RepresentationItem
+{
+
+public:
+
+
+ //! Returns a ValueRepresentationItem
+ Standard_EXPORT StepRepr_ValueRepresentationItem();
+
+ Standard_EXPORT virtual void Init (const Handle(TCollection_HAsciiString)& theName,
+ const Handle(StepBasic_MeasureValueMember)& theValueComponentMember);
+
+ inline void SetValueComponentMember(const Handle(StepBasic_MeasureValueMember)& theValueComponentMember)
+ {
+ valueComponentMember = theValueComponentMember;
+ }
+
+ inline Handle(StepBasic_MeasureValueMember) ValueComponentMember() const
+ {
+ return valueComponentMember;
+ }
+
+ DEFINE_STANDARD_RTTI(StepRepr_ValueRepresentationItem,StepRepr_RepresentationItem)
+
+private:
+ Handle(StepBasic_MeasureValueMember) valueComponentMember;
+};
+#endif // _StepRepr_ValueRepresentationItem_HeaderFile
StepShape_Array1OfGeometricSetSelect.hxx
StepShape_Array1OfOrientedClosedShell.hxx
StepShape_Array1OfOrientedEdge.hxx
+StepShape_Array1OfShapeDimensionRepresentationItem.hxx
StepShape_Array1OfShell.hxx
StepShape_Array1OfValueQualifier.hxx
StepShape_Block.cxx
StepShape_HArray1OfGeometricSetSelect.hxx
StepShape_HArray1OfOrientedClosedShell.hxx
StepShape_HArray1OfOrientedEdge.hxx
+StepShape_HArray1OfShapeDimensionRepresentationItem.hxx
StepShape_HArray1OfShell.hxx
StepShape_HArray1OfValueQualifier.hxx
StepShape_LimitsAndFits.cxx
StepShape_ShapeDefinitionRepresentation.hxx
StepShape_ShapeDimensionRepresentation.cxx
StepShape_ShapeDimensionRepresentation.hxx
+StepShape_ShapeDimensionRepresentationItem.cxx
+StepShape_ShapeDimensionRepresentationItem.hxx
StepShape_ShapeRepresentation.cxx
StepShape_ShapeRepresentation.hxx
StepShape_ShapeRepresentationWithParameters.cxx
StepShape_TransitionalShapeRepresentation.hxx
StepShape_TypeQualifier.cxx
StepShape_TypeQualifier.hxx
+StepShape_ValueFormatTypeQualifier.cxx
+StepShape_ValueFormatTypeQualifier.hxx
StepShape_ValueQualifier.cxx
StepShape_ValueQualifier.hxx
StepShape_Vertex.cxx
--- /dev/null
+// Created on: 2015-07-21
+// Created by: Irina KRYLOVA
+// 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 _StepShape_Array1OfShapeDimensionRepresentationItem_HeaderFile
+#define _StepShape_Array1OfShapeDimensionRepresentationItem_HeaderFile
+
+#include <StepShape_ShapeDimensionRepresentationItem.hxx>
+#include <NCollection_Array1.hxx>
+
+typedef NCollection_Array1<StepShape_ShapeDimensionRepresentationItem> StepShape_Array1OfShapeDimensionRepresentationItem;
+#endif // _StepShape_Array1OfShapeDimensionRepresentationItem_HeaderFile
--- /dev/null
+// Created on: 2015-07-21
+// Created by: Irina KRYLOVA
+// 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 _StepShape_HArray1OfShapeDimensionRepresentationItem_HeaderFile
+#define _StepShape_HArray1OfShapeDimensionRepresentationItem_HeaderFile
+
+#include <StepShape_ShapeDimensionRepresentationItem.hxx>
+#include <StepShape_Array1OfShapeDimensionRepresentationItem.hxx>
+#include <NCollection_DefineHArray1.hxx>
+
+DEFINE_HARRAY1(StepShape_HArray1OfShapeDimensionRepresentationItem, StepShape_Array1OfShapeDimensionRepresentationItem)
+#endif // _StepShape_HArray1OfShapeDimensionRepresentationItem_HeaderFile
StepShape_ShapeDimensionRepresentation::StepShape_ShapeDimensionRepresentation ()
{
}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+void StepShape_ShapeDimensionRepresentation::Init (const Handle(TCollection_HAsciiString)& theName,
+ const Handle(StepRepr_HArray1OfRepresentationItem)& theItems,
+ const Handle(StepRepr_RepresentationContext)& theContextOfItems)
+{
+ StepRepr_Representation::Init(theName, theItems, theContextOfItems);
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepShape_ShapeDimensionRepresentation::Init (const Handle(TCollection_HAsciiString)& theName,
+ const Handle(StepShape_HArray1OfShapeDimensionRepresentationItem)& theItems,
+ const Handle(StepRepr_RepresentationContext)& theContextOfItems)
+{
+ StepRepr_Representation::Init(theName, NULL, theContextOfItems);
+ itemsAP242 = theItems;
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepShape_ShapeDimensionRepresentation::SetItemsAP242 (const Handle(StepShape_HArray1OfShapeDimensionRepresentationItem)& theItems)
+{
+ itemsAP242 = theItems;
+}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+Handle(StepShape_HArray1OfShapeDimensionRepresentationItem) StepShape_ShapeDimensionRepresentation::ItemsAP242() const
+{
+ return itemsAP242;
+}
#include <Standard.hxx>
#include <Standard_Type.hxx>
+#include <StepShape_HArray1OfShapeDimensionRepresentationItem.hxx>
#include <StepShape_ShapeRepresentation.hxx>
//! Empty constructor
Standard_EXPORT StepShape_ShapeDimensionRepresentation();
+
+ //! Initialize all fields AP214
+ Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& theName, const Handle(StepRepr_HArray1OfRepresentationItem)& theItems, const Handle(StepRepr_RepresentationContext)& theContextOfItems);
+ //! Initialize all fields AP242
+ Standard_EXPORT void Init (const Handle(TCollection_HAsciiString)& theName, const Handle(StepShape_HArray1OfShapeDimensionRepresentationItem)& theItems, const Handle(StepRepr_RepresentationContext)& theContextOfItems);
-
-
+ Standard_EXPORT void SetItemsAP242 (const Handle(StepShape_HArray1OfShapeDimensionRepresentationItem)& theItems);
+
+ Standard_EXPORT Handle(StepShape_HArray1OfShapeDimensionRepresentationItem) ItemsAP242() const;
+
DEFINE_STANDARD_RTTI(StepShape_ShapeDimensionRepresentation,StepShape_ShapeRepresentation)
-
-protected:
-
-
-
-
private:
-
-
-
+ Handle(StepShape_HArray1OfShapeDimensionRepresentationItem) itemsAP242;
};
-
-
-
-
-
-
-
#endif // _StepShape_ShapeDimensionRepresentation_HeaderFile
--- /dev/null
+// Created on: 2015-07-21
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepShape_ShapeDimensionRepresentationItem.hxx>
+#include <Interface_Macros.hxx>
+#include <StepRepr_CompoundRepresentationItem.hxx>
+#include <StepRepr_DescriptiveRepresentationItem.hxx>
+#include <StepRepr_MeasureRepresentationItem.hxx>
+#include <StepGeom_Placement.hxx>
+
+//=======================================================================
+//function : StepShape_ShapeDimensionRepresentationItem
+//purpose :
+//=======================================================================
+
+StepShape_ShapeDimensionRepresentationItem::StepShape_ShapeDimensionRepresentationItem () { }
+
+//=======================================================================
+//function : CaseNum
+//purpose :
+//=======================================================================
+
+Standard_Integer StepShape_ShapeDimensionRepresentationItem::CaseNum(const Handle(Standard_Transient)& ent) const
+{
+ if (ent.IsNull()) return 0;
+ if (ent->IsKind(STANDARD_TYPE(StepRepr_CompoundRepresentationItem))) return 1;
+ if (ent->IsKind(STANDARD_TYPE(StepRepr_DescriptiveRepresentationItem))) return 2;
+ if (ent->IsKind(STANDARD_TYPE(StepRepr_MeasureRepresentationItem))) return 3;
+ if (ent->IsKind(STANDARD_TYPE(StepGeom_Placement))) return 4;
+ return 0;
+}
+
+Handle(StepRepr_CompoundRepresentationItem) StepShape_ShapeDimensionRepresentationItem::CompoundRepresentationItem() const
+{ return GetCasted(StepRepr_CompoundRepresentationItem,Value()); }
+
+Handle(StepRepr_DescriptiveRepresentationItem) StepShape_ShapeDimensionRepresentationItem::DescriptiveRepresentationItem() const
+{ return GetCasted(StepRepr_DescriptiveRepresentationItem,Value()); }
+
+Handle(StepRepr_MeasureRepresentationItem) StepShape_ShapeDimensionRepresentationItem::MeasureRepresentationItem() const
+{ return GetCasted(StepRepr_MeasureRepresentationItem,Value()); }
+
+Handle(StepGeom_Placement) StepShape_ShapeDimensionRepresentationItem::Placement() const
+{ return GetCasted(StepGeom_Placement,Value()); }
--- /dev/null
+// Created on: 2015-07-21
+// Created by: Irina KRYLOVA
+// 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 _StepShape_ShapeDimensionRepresentationItem_HeaderFile
+#define _StepShape_ShapeDimensionRepresentationItem_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+#include <StepData_SelectType.hxx>
+#include <Standard_Integer.hxx>
+
+class Standard_Transient;
+class StepRepr_CompoundRepresentationItem;
+class StepRepr_DescriptiveRepresentationItem;
+class StepRepr_MeasureRepresentationItem;
+class StepGeom_Placement;
+
+class StepShape_ShapeDimensionRepresentationItem : public StepData_SelectType
+{
+public:
+
+ DEFINE_STANDARD_ALLOC
+
+ //! Returns a ShapeDimensionRepresentationItem select type
+ Standard_EXPORT StepShape_ShapeDimensionRepresentationItem();
+
+ //! Recognizes a ShapeDimensionRepresentationItem Kind Entity that is :
+ //! 1 -> CompoundRepresentationItem
+ //! 2 -> DescriptiveRepresentationItem
+ //! 3 -> MeasureRepresentationItem
+ //! 4 -> Placement
+ //! 0 else
+ Standard_EXPORT Standard_Integer CaseNum (const Handle(Standard_Transient)& ent) const;
+
+ //! returns Value as a CompoundRepresentationItem (Null if another type)
+ Standard_EXPORT Handle(StepRepr_CompoundRepresentationItem) CompoundRepresentationItem() const;
+
+ //! returns Value as a DescriptiveRepresentationItem (Null if another type)
+ Standard_EXPORT Handle(StepRepr_DescriptiveRepresentationItem) DescriptiveRepresentationItem() const;
+
+ //! returns Value as a MeasureRepresentationItem (Null if another type)
+ Standard_EXPORT Handle(StepRepr_MeasureRepresentationItem) MeasureRepresentationItem() const;
+
+ //! returns Value as a Placement (Null if another type)
+ Standard_EXPORT Handle(StepGeom_Placement) Placement() const;
+};
+#endif // _StepShape_ShapeDimensionRepresentationItem_HeaderFile
--- /dev/null
+// Created on: 2015-07-14
+// Created by: Irina KRYLOVA
+// 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.
+
+#include <StepShape_ValueFormatTypeQualifier.hxx>
+
+//=======================================================================
+//function : StepShape_ValueFormatTypeQualifier
+//purpose :
+//=======================================================================
+
+StepShape_ValueFormatTypeQualifier::StepShape_ValueFormatTypeQualifier () {}
+
+//=======================================================================
+//function : Init
+//purpose :
+//=======================================================================
+
+void StepShape_ValueFormatTypeQualifier::Init(
+ const Handle(TCollection_HAsciiString)& theFormatType)
+{
+ // --- classe own fields ---
+ formatType = theFormatType;
+}
--- /dev/null
+// Created on: 2015-07-14
+// Created by: Irina KRYLOVA
+// 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 _StepShape_ValueFormatTypeQualifier_HeaderFile
+#define _StepShape_ValueFormatTypeQualifier_HeaderFile
+
+#include <StepShape_ValueFormatTypeQualifier.hxx>
+
+#include <MMgt_TShared.hxx>
+#include <Standard.hxx>
+#include <Standard_Type.hxx>
+#include <TCollection_HAsciiString.hxx>
+
+class TCollection_HAsciiString;
+
+class StepShape_ValueFormatTypeQualifier;
+DEFINE_STANDARD_HANDLE(StepShape_ValueFormatTypeQualifier, MMgt_TShared)
+//! Added for Dimensional Tolerances
+class StepShape_ValueFormatTypeQualifier : public MMgt_TShared
+{
+
+public:
+
+ Standard_EXPORT StepShape_ValueFormatTypeQualifier();
+
+ //! Init all field own and inherited
+ Standard_EXPORT virtual void Init (const Handle(TCollection_HAsciiString)& theFormatType);
+
+ //! Returns field FormatType
+ inline Handle(TCollection_HAsciiString) FormatType()
+ {
+ return formatType;
+ }
+
+ //! Set field FormatType
+ inline void SetFormatType(const Handle(TCollection_HAsciiString) &theFormatType)
+ {
+ formatType = theFormatType;
+ }
+
+ DEFINE_STANDARD_RTTI(StepShape_ValueFormatTypeQualifier, MMgt_TShared)
+
+private:
+ Handle(TCollection_HAsciiString) formatType;
+
+};
+#endif // _StepShape_ValueFormatTypeQualifier_HeaderFile
STEPControl
STEPSelections
StepAP209
+ StepAP242
+ RWStepAP242
)
if (WIN32)
STEPControl
STEPSelections
StepAP209
+RWStepAP242
+StepAP242
projects / occt-copy.git / commitdiff