OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-03 17:56:21 +03:00
Code Packages Releases Activity

0026371: Implementation of new entities for GD&T

Browse Source 
Implement entities:
- DatumReferenceCompartment,
- DatumReferenceElement,
- DatumReferenceModifierWithValue,
- DatumSystem,
- GeneralDatumReference,

- ValueFormatTypeQualifier,

- NonUniformZoneDefinition,
- ProjectedZoneDefinition,
- RunoutZoneDefinition,
- RunoutZoneOrientation,
- ToleranceZone,
- ToleranceZoneDefinition,
- ToleranceZoneForm,
- ToleranceZoneTarget,

- GeometricToleranceWithDefinedAreaUnit,
- GeometricToleranceWithDefinedUnit,
- GeometricToleranceWithMaximumTolerance,
- GeometricToleranceWithModifiers,
- UnequallyDisposedGeometricTolerance,

- GeometricItemSpecificUsage,
- IdAttribute,
- IdAttributeSelect,
- ItemIdentifiedRepresentationUsage,
- ItemIdentifiedRepresentationUsageDefinition,

- Apex,
- CentreOfSymmetry,
- GeometricAlignment,
- ParallelOffset,
- PerpendicularTo,
- Tangent,

- AllAroundShapeAspect,
- BetweenShapeAspect,
- CompositeGroupShapeAspect,
- ContinuosShapeAspect,

- ReprItemAndLengthMeasureWithUnitAndQRI,
- ReprItemAndPlaneAngleMeasureWithUnitAndQRI,
- ReprItemAndPlaneAngleMeasureWithUnit,

- CompGroupShAspAndCompShAspAndDatumFeatAndShAsp,
- CompShAspAndDatumFeatAndShAsp,

- GeoTolAndGeoTolWthDatRef,
- GeoTolAndGeoTolWthDatRefAndGeoTolWthMod,
- GeoTolAndGeoTolWthMod,
- GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol,

- IntegerRepresentationItem,
- ValueRepresentationItem.

Modify entities:
- GeometricTolerance,
- GeometricToleranceWithDatumReference,
- ShapeDimensionRepresentation.

fix compilation error

fix compilation warning
This commit is contained in:
ika 2015-09-24 12:12:47 +03:00 committed by kgv
parent a576c3e54d
commit 28a73c1fe7
261 changed files with 15894 additions and 611 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
adm/UDLIST
View File

@ -311,6 +311,7 @@ n MoniTool
n RWHeaderSection
n RWStepAP203
n RWStepAP214
n RWStepAP242
n RWStepBasic
n RWStepDimTol
n RWStepElement
@ -328,6 +329,7 @@ n STEPSelections
n StepAP203
n StepAP209
n StepAP214
n StepAP242
n StepBasic
n StepData
n StepDimTol

515
src/RWStepAP214/RWStepAP214_GeneralModule.cxx
View File

@ -178,6 +178,7 @@
#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>
@ -705,6 +706,7 @@
#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>
@ -1216,6 +1218,98 @@
// 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;
@ -4435,6 +4529,13 @@ void RWStepAP214_GeneralModule::FillSharedCase(const Standard_Integer CN,
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);
@ -4634,8 +4735,242 @@ void RWStepAP214_GeneralModule::FillSharedCase(const Standard_Integer CN,
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;
}
}
@ -6364,7 +6699,9 @@ Standard_Boolean RWStepAP214_GeneralModule::NewVoid
case 601:
ent = new StepBasic_DocumentProductEquivalence;
break;
case 609:
ent = new StepDimTol_CylindricityTolerance;
break;
case 610:
ent = new StepShape_ShapeRepresentationWithParameters;
break;
@ -6454,8 +6791,133 @@ Standard_Boolean RWStepAP214_GeneralModule::NewVoid
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;
}
@ -6964,6 +7426,7 @@ Standard_Integer RWStepAP214_GeneralModule::CategoryNumber
case 496: return catsh;
case 600:
case 601: return cataux;
case 609:
case 610:
case 611:
case 612:
@ -6993,6 +7456,48 @@ Standard_Integer RWStepAP214_GeneralModule::CategoryNumber
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;
}

1497
src/RWStepAP214/RWStepAP214_ReadWriteModule.cxx
View File

File diff suppressed because it is too large Load Diff

6
src/RWStepAP242/FILES Normal file
View File

@ -0,0 +1,6 @@
RWStepAP242_RWGeometricItemSpecificUsage.cxx
RWStepAP242_RWGeometricItemSpecificUsage.hxx
RWStepAP242_RWIdAttribute.cxx
RWStepAP242_RWIdAttribute.hxx
RWStepAP242_RWItemIdentifiedRepresentationUsage.cxx
RWStepAP242_RWItemIdentifiedRepresentationUsage.hxx

115
src/RWStepAP242/RWStepAP242_RWGeometricItemSpecificUsage.cxx Normal file
View File

@ -0,0 +1,115 @@
// 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));
}

48
src/RWStepAP242/RWStepAP242_RWGeometricItemSpecificUsage.hxx Normal file
View File

@ -0,0 +1,48 @@
// 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

70
src/RWStepAP242/RWStepAP242_RWIdAttribute.cxx Normal file
View File

@ -0,0 +1,70 @@
// 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());
}

48
src/RWStepAP242/RWStepAP242_RWIdAttribute.hxx Normal file
View File

@ -0,0 +1,48 @@
// 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

131
src/RWStepAP242/RWStepAP242_RWItemIdentifiedRepresentationUsage.cxx Normal file
View File

@ -0,0 +1,131 @@
// 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));
}

48
src/RWStepAP242/RWStepAP242_RWItemIdentifiedRepresentationUsage.hxx Normal file
View File

@ -0,0 +1,48 @@
// 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

42
src/RWStepDimTol/FILES
View File

@ -16,22 +16,50 @@ RWStepDimTol_RWDatumFeature.cxx
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
@ -40,13 +68,27 @@ RWStepDimTol_RWPlacedDatumTargetFeature.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

32
src/RWStepDimTol/RWStepDimTol_RWAngularityTolerance.cxx
View File

@ -23,8 +23,8 @@
#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
@ -58,20 +58,20 @@ void RWStepDimTol_RWAngularityTolerance::ReadStep (const Handle(StepData_StepRea
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);
}
}
@ -101,14 +101,14 @@ void RWStepDimTol_RWAngularityTolerance::WriteStep (StepData_StepWriter& SW,
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();
}
@ -126,12 +126,12 @@ void RWStepDimTol_RWAngularityTolerance::Share (const Handle(StepDimTol_Angulari
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());
}
}

32
src/RWStepDimTol/RWStepDimTol_RWCircularRunoutTolerance.cxx
View File

@ -23,8 +23,8 @@
#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
@ -58,20 +58,20 @@ void RWStepDimTol_RWCircularRunoutTolerance::ReadStep (const Handle(StepData_Ste
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);
}
}
@ -101,14 +101,14 @@ void RWStepDimTol_RWCircularRunoutTolerance::WriteStep (StepData_StepWriter& SW,
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();
}
@ -126,12 +126,12 @@ void RWStepDimTol_RWCircularRunoutTolerance::Share (const Handle(StepDimTol_Circ
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());
}
}

32
src/RWStepDimTol/RWStepDimTol_RWCoaxialityTolerance.cxx
View File

@ -23,8 +23,8 @@
#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
@ -58,20 +58,20 @@ void RWStepDimTol_RWCoaxialityTolerance::ReadStep (const Handle(StepData_StepRea
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);
}
}
@ -101,14 +101,14 @@ void RWStepDimTol_RWCoaxialityTolerance::WriteStep (StepData_StepWriter& SW,
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();
}
@ -126,12 +126,12 @@ void RWStepDimTol_RWCoaxialityTolerance::Share (const Handle(StepDimTol_Coaxiali
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());
}
}

32
src/RWStepDimTol/RWStepDimTol_RWConcentricityTolerance.cxx
View File

@ -23,8 +23,8 @@
#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
@ -58,20 +58,20 @@ void RWStepDimTol_RWConcentricityTolerance::ReadStep (const Handle(StepData_Step
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);
}
}
@ -101,14 +101,14 @@ void RWStepDimTol_RWConcentricityTolerance::WriteStep (StepData_StepWriter& SW,
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();
}
@ -126,12 +126,12 @@ void RWStepDimTol_RWConcentricityTolerance::Share (const Handle(StepDimTol_Conce
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());
}
}

10
src/RWStepDimTol/RWStepDimTol_RWCylindricityTolerance.cxx
View File

@ -22,7 +22,7 @@
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_CylindricityTolerance.hxx>
#include <StepRepr_ShapeAspect.hxx>
#include <StepDimTol_GeometricToleranceTarget.hxx>
//=======================================================================
//function : RWStepDimTol_RWCylindricityTolerance
@ -56,8 +56,8 @@ void RWStepDimTol_RWCylindricityTolerance::ReadStep (const Handle(StepData_StepR
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,
@ -83,7 +83,7 @@ void RWStepDimTol_RWCylindricityTolerance::WriteStep (StepData_StepWriter& SW,
SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
}
//=======================================================================
@ -99,5 +99,5 @@ void RWStepDimTol_RWCylindricityTolerance::Share (const Handle(StepDimTol_Cylind
iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
}

205
src/RWStepDimTol/RWStepDimTol_RWDatumReferenceCompartment.cxx Normal file
View File

@ -0,0 +1,205 @@
// 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));
}
}

52
src/RWStepDimTol/RWStepDimTol_RWDatumReferenceCompartment.hxx Normal file
View File

@ -0,0 +1,52 @@
// 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

207
src/RWStepDimTol/RWStepDimTol_RWDatumReferenceElement.cxx Normal file
View File

@ -0,0 +1,207 @@
// 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));
}
}

52
src/RWStepDimTol/RWStepDimTol_RWDatumReferenceElement.hxx Normal file
View File

@ -0,0 +1,52 @@
// 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

89
src/RWStepDimTol/RWStepDimTol_RWDatumReferenceModifierWithValue.cxx Normal file
View File

@ -0,0 +1,89 @@
// 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());
}

49
src/RWStepDimTol/RWStepDimTol_RWDatumReferenceModifierWithValue.hxx Normal file
View File

@ -0,0 +1,49 @@
// 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

129
src/RWStepDimTol/RWStepDimTol_RWDatumSystem.cxx Normal file
View File

@ -0,0 +1,129 @@
// 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));
}

52
src/RWStepDimTol/RWStepDimTol_RWDatumSystem.hxx Normal file
View File

@ -0,0 +1,52 @@
// 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

10
src/RWStepDimTol/RWStepDimTol_RWFlatnessTolerance.cxx
View File

@ -22,7 +22,7 @@
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_FlatnessTolerance.hxx>
#include <StepRepr_ShapeAspect.hxx>
#include <StepDimTol_GeometricToleranceTarget.hxx>
//=======================================================================
//function : RWStepDimTol_RWFlatnessTolerance
@ -56,8 +56,8 @@ void RWStepDimTol_RWFlatnessTolerance::ReadStep (const Handle(StepData_StepReade
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,
@ -83,7 +83,7 @@ void RWStepDimTol_RWFlatnessTolerance::WriteStep (StepData_StepWriter& SW,
SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
}
//=======================================================================
@ -99,5 +99,5 @@ void RWStepDimTol_RWFlatnessTolerance::Share (const Handle(StepDimTol_FlatnessTo
iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
}

205
src/RWStepDimTol/RWStepDimTol_RWGeneralDatumReference.cxx Normal file
View File

@ -0,0 +1,205 @@
// 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));
}
}

52
src/RWStepDimTol/RWStepDimTol_RWGeneralDatumReference.hxx Normal file
View File

@ -0,0 +1,52 @@
// 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

184
src/RWStepDimTol/RWStepDimTol_RWGeoTolAndGeoTolWthDatRef.cxx Normal file
View File

@ -0,0 +1,184 @@
// 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());
}
}

47
src/RWStepDimTol/RWStepDimTol_RWGeoTolAndGeoTolWthDatRef.hxx Normal file
View File

@ -0,0 +1,47 @@
// 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

222
src/RWStepDimTol/RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMod.cxx Normal file
View File

@ -0,0 +1,222 @@
// 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());
}
}

47
src/RWStepDimTol/RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMod.hxx Normal file
View File

@ -0,0 +1,47 @@
// 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

34
src/RWStepDimTol/RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndModGeoTolAndPosTol.cxx
View File

@ -19,12 +19,12 @@
#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
@ -55,20 +55,20 @@ void RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndModGeoTolAndPosTol::ReadStep
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);
}
}
@ -110,13 +110,13 @@ void RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndModGeoTolAndPosTol::WriteStep
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");
@ -140,10 +140,10 @@ void RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndModGeoTolAndPosTol::Share
{
// 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());
}
}

197
src/RWStepDimTol/RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndUneqDisGeoTol.cxx Normal file
View File

@ -0,0 +1,197 @@
// 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());
}
}

47
src/RWStepDimTol/RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndUneqDisGeoTol.hxx Normal file
View File

@ -0,0 +1,47 @@
// 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

209
src/RWStepDimTol/RWStepDimTol_RWGeoTolAndGeoTolWthMod.cxx Normal file
View File

@ -0,0 +1,209 @@
// 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());
}

47
src/RWStepDimTol/RWStepDimTol_RWGeoTolAndGeoTolWthMod.hxx Normal file
View File

@ -0,0 +1,47 @@
// 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

10
src/RWStepDimTol/RWStepDimTol_RWGeometricTolerance.cxx
View File

@ -22,7 +22,7 @@
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_GeometricTolerance.hxx>
#include <StepRepr_ShapeAspect.hxx>
#include <StepDimTol_GeometricToleranceTarget.hxx>
//=======================================================================
//function : RWStepDimTol_RWGeometricTolerance
@ -56,8 +56,8 @@ void RWStepDimTol_RWGeometricTolerance::ReadStep (const Handle(StepData_StepRead
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,
@ -83,7 +83,7 @@ void RWStepDimTol_RWGeometricTolerance::WriteStep (StepData_StepWriter& SW,
SW.Send (ent->Magnitude());
SW.Send (ent->TolerancedShapeAspect());
SW.Send (ent->TolerancedShapeAspect().Value());
}
//=======================================================================
@ -99,5 +99,5 @@ void RWStepDimTol_RWGeometricTolerance::Share (const Handle(StepDimTol_Geometric
iter.AddItem (ent->Magnitude());
iter.AddItem (ent->TolerancedShapeAspect());
iter.AddItem (ent->TolerancedShapeAspect().Value());
}

32
src/RWStepDimTol/RWStepDimTol_RWGeometricToleranceWithDatumReference.cxx
View File

@ -22,9 +22,9 @@
#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
@ -58,20 +58,20 @@ void RWStepDimTol_RWGeometricToleranceWithDatumReference::ReadStep (const Handle
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);
}
}
@ -101,14 +101,14 @@ void RWStepDimTol_RWGeometricToleranceWithDatumReference::WriteStep (StepData_St
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();
}
@ -126,12 +126,12 @@ void RWStepDimTol_RWGeometricToleranceWithDatumReference::Share (const Handle(St
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());
}
}

150
src/RWStepDimTol/RWStepDimTol_RWGeometricToleranceWithDefinedAreaUnit.cxx Normal file
View File

@ -0,0 +1,150 @@
// 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());
}

52
src/RWStepDimTol/RWStepDimTol_RWGeometricToleranceWithDefinedAreaUnit.hxx Normal file
View File

@ -0,0 +1,52 @@
// 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

114
src/RWStepDimTol/RWStepDimTol_RWGeometricToleranceWithDefinedUnit.cxx Normal file
View File

@ -0,0 +1,114 @@
// 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());
}

52
src/RWStepDimTol/RWStepDimTol_RWGeometricToleranceWithDefinedUnit.hxx Normal file
View File

@ -0,0 +1,52 @@
// 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

176
src/RWStepDimTol/RWStepDimTol_RWGeometricToleranceWithMaximumTolerance.cxx Normal file
View File

@ -0,0 +1,176 @@
// 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());
}

52
src/RWStepDimTol/RWStepDimTol_RWGeometricToleranceWithMaximumTolerance.hxx Normal file
View File

@ -0,0 +1,52 @@
// 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

166
src/RWStepDimTol/RWStepDimTol_RWGeometricToleranceWithModifiers.cxx Normal file
View File

@ -0,0 +1,166 @@
// 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());
}

52
src/RWStepDimTol/RWStepDimTol_RWGeometricToleranceWithModifiers.hxx Normal file
View File

@ -0,0 +1,52 @@
// 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

10
src/RWStepDimTol/RWStepDimTol_RWLineProfileTolerance.cxx
View File

@ -21,8 +21,8 @@
#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
@ -56,8 +56,8 @@ void RWStepDimTol_RWLineProfileTolerance::ReadStep (const Handle(StepData_StepRe
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,
@ -83,7 +83,7 @@ void RWStepDimTol_RWLineProfileTolerance::WriteStep (StepData_StepWriter& SW,
SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
}
//=======================================================================
@ -99,5 +99,5 @@ void RWStepDimTol_RWLineProfileTolerance::Share (const Handle(StepDimTol_LinePro
iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
}

10
src/RWStepDimTol/RWStepDimTol_RWModifiedGeometricTolerance.cxx
View File

@ -21,8 +21,8 @@
#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
@ -56,8 +56,8 @@ void RWStepDimTol_RWModifiedGeometricTolerance::ReadStep (const Handle(StepData_
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
@ -96,7 +96,7 @@ void RWStepDimTol_RWModifiedGeometricTolerance::WriteStep (StepData_StepWriter&
SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
// Own fields of ModifiedGeometricTolerance
@ -120,7 +120,7 @@ void RWStepDimTol_RWModifiedGeometricTolerance::Share (const Handle(StepDimTol_M
iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
// Own fields of ModifiedGeometricTolerance
}

104
src/RWStepDimTol/RWStepDimTol_RWNonUniformZoneDefinition.cxx Normal file
View File

@ -0,0 +1,104 @@
// 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));
}

52
src/RWStepDimTol/RWStepDimTol_RWNonUniformZoneDefinition.hxx Normal file
View File

@ -0,0 +1,52 @@
// 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

32
src/RWStepDimTol/RWStepDimTol_RWParallelismTolerance.cxx
View File

@ -22,9 +22,9 @@
#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
@ -58,20 +58,20 @@ void RWStepDimTol_RWParallelismTolerance::ReadStep (const Handle(StepData_StepRe
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);
}
}
@ -101,14 +101,14 @@ void RWStepDimTol_RWParallelismTolerance::WriteStep (StepData_StepWriter& SW,
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();
}
@ -126,12 +126,12 @@ void RWStepDimTol_RWParallelismTolerance::Share (const Handle(StepDimTol_Paralle
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());
}
}

32
src/RWStepDimTol/RWStepDimTol_RWPerpendicularityTolerance.cxx
View File

@ -22,9 +22,9 @@
#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
@ -58,20 +58,20 @@ void RWStepDimTol_RWPerpendicularityTolerance::ReadStep (const Handle(StepData_S
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);
}
}
@ -101,14 +101,14 @@ void RWStepDimTol_RWPerpendicularityTolerance::WriteStep (StepData_StepWriter& S
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();
}
@ -126,12 +126,12 @@ void RWStepDimTol_RWPerpendicularityTolerance::Share (const Handle(StepDimTol_Pe
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());
}
}

10
src/RWStepDimTol/RWStepDimTol_RWPositionTolerance.cxx
View File

@ -21,8 +21,8 @@
#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
@ -56,8 +56,8 @@ void RWStepDimTol_RWPositionTolerance::ReadStep (const Handle(StepData_StepReade
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,
@ -83,7 +83,7 @@ void RWStepDimTol_RWPositionTolerance::WriteStep (StepData_StepWriter& SW,
SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
}
//=======================================================================
@ -99,5 +99,5 @@ void RWStepDimTol_RWPositionTolerance::Share (const Handle(StepDimTol_PositionTo
iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
}

122
src/RWStepDimTol/RWStepDimTol_RWProjectedZoneDefinition.cxx Normal file
View File

@ -0,0 +1,122 @@
// 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());
}

52
src/RWStepDimTol/RWStepDimTol_RWProjectedZoneDefinition.hxx Normal file
View File

@ -0,0 +1,52 @@
// 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

10
src/RWStepDimTol/RWStepDimTol_RWRoundnessTolerance.cxx
View File

@ -21,8 +21,8 @@
#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
@ -56,8 +56,8 @@ void RWStepDimTol_RWRoundnessTolerance::ReadStep (const Handle(StepData_StepRead
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,
@ -83,7 +83,7 @@ void RWStepDimTol_RWRoundnessTolerance::WriteStep (StepData_StepWriter& SW,
SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
}
//=======================================================================
@ -99,5 +99,5 @@ void RWStepDimTol_RWRoundnessTolerance::Share (const Handle(StepDimTol_Roundness
iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
}

109
src/RWStepDimTol/RWStepDimTol_RWRunoutZoneDefinition.cxx Normal file
View File

@ -0,0 +1,109 @@
// 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));
}

52
src/RWStepDimTol/RWStepDimTol_RWRunoutZoneDefinition.hxx Normal file
View File

@ -0,0 +1,52 @@
// 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

63
src/RWStepDimTol/RWStepDimTol_RWRunoutZoneOrientation.cxx Normal file
View File

@ -0,0 +1,63 @@
// 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());
}

49
src/RWStepDimTol/RWStepDimTol_RWRunoutZoneOrientation.hxx Normal file
View File

@ -0,0 +1,49 @@
// 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

10
src/RWStepDimTol/RWStepDimTol_RWStraightnessTolerance.cxx
View File

@ -21,8 +21,8 @@
#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
@ -56,8 +56,8 @@ void RWStepDimTol_RWStraightnessTolerance::ReadStep (const Handle(StepData_StepR
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,
@ -83,7 +83,7 @@ void RWStepDimTol_RWStraightnessTolerance::WriteStep (StepData_StepWriter& SW,
SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
}
//=======================================================================
@ -99,5 +99,5 @@ void RWStepDimTol_RWStraightnessTolerance::Share (const Handle(StepDimTol_Straig
iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
}

10
src/RWStepDimTol/RWStepDimTol_RWSurfaceProfileTolerance.cxx
View File

@ -21,8 +21,8 @@
#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
@ -56,8 +56,8 @@ void RWStepDimTol_RWSurfaceProfileTolerance::ReadStep (const Handle(StepData_Ste
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,
@ -83,7 +83,7 @@ void RWStepDimTol_RWSurfaceProfileTolerance::WriteStep (StepData_StepWriter& SW,
SW.Send (ent->StepDimTol_GeometricTolerance::Magnitude());
SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
SW.Send (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
}
//=======================================================================
@ -99,5 +99,5 @@ void RWStepDimTol_RWSurfaceProfileTolerance::Share (const Handle(StepDimTol_Surf
iter.AddItem (ent->StepDimTol_GeometricTolerance::Magnitude());
iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect());
iter.AddItem (ent->StepDimTol_GeometricTolerance::TolerancedShapeAspect().Value());
}

32
src/RWStepDimTol/RWStepDimTol_RWSymmetryTolerance.cxx
View File

@ -22,9 +22,9 @@
#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
@ -58,20 +58,20 @@ void RWStepDimTol_RWSymmetryTolerance::ReadStep (const Handle(StepData_StepReade
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);
}
}
@ -101,14 +101,14 @@ void RWStepDimTol_RWSymmetryTolerance::WriteStep (StepData_StepWriter& SW,
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();
}
@ -126,12 +126,12 @@ void RWStepDimTol_RWSymmetryTolerance::Share (const Handle(StepDimTol_SymmetryTo
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());
}
}

138
src/RWStepDimTol/RWStepDimTol_RWToleranceZone.cxx Normal file
View File

@ -0,0 +1,138 @@
// 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());
}

52
src/RWStepDimTol/RWStepDimTol_RWToleranceZone.hxx Normal file
View File

@ -0,0 +1,52 @@
// 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

104
src/RWStepDimTol/RWStepDimTol_RWToleranceZoneDefinition.cxx Normal file
View File

@ -0,0 +1,104 @@
// 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));
}

52
src/RWStepDimTol/RWStepDimTol_RWToleranceZoneDefinition.hxx Normal file
View File

@ -0,0 +1,52 @@
// 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

62
src/RWStepDimTol/RWStepDimTol_RWToleranceZoneForm.cxx Normal file
View File

@ -0,0 +1,62 @@
// 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());
}

49
src/RWStepDimTol/RWStepDimTol_RWToleranceZoneForm.hxx Normal file
View File

@ -0,0 +1,49 @@
// 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

32
src/RWStepDimTol/RWStepDimTol_RWTotalRunoutTolerance.cxx
View File

@ -22,9 +22,9 @@
#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
@ -58,20 +58,20 @@ void RWStepDimTol_RWTotalRunoutTolerance::ReadStep (const Handle(StepData_StepRe
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);
}
}
@ -101,14 +101,14 @@ void RWStepDimTol_RWTotalRunoutTolerance::WriteStep (StepData_StepWriter& SW,
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();
}
@ -126,12 +126,12 @@ void RWStepDimTol_RWTotalRunoutTolerance::Share (const Handle(StepDimTol_TotalRu
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());
}
}

114
src/RWStepDimTol/RWStepDimTol_RWUnequallyDisposedGeometricTolerance.cxx Normal file
View File

@ -0,0 +1,114 @@
// 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());
}

52
src/RWStepDimTol/RWStepDimTol_RWUnequallyDisposedGeometricTolerance.hxx Normal file
View File

@ -0,0 +1,52 @@
// 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

34
src/RWStepRepr/FILES
View File

@ -1,17 +1,33 @@
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
@ -24,10 +40,14 @@ RWStepRepr_RWExtension.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
@ -42,8 +62,12 @@ RWStepRepr_RWMaterialPropertyRepresentation.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
@ -70,6 +94,12 @@ RWStepRepr_RWRepresentationRelationshipWithTransformation.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
@ -86,3 +116,7 @@ RWStepRepr_RWStructuralResponseProperty.cxx
RWStepRepr_RWStructuralResponseProperty.hxx
RWStepRepr_RWStructuralResponsePropertyDefinitionRepresentation.cxx
RWStepRepr_RWStructuralResponsePropertyDefinitionRepresentation.hxx
RWStepRepr_RWTangent.cxx
RWStepRepr_RWTangent.hxx
RWStepRepr_RWValueRepresentationItem.cxx
RWStepRepr_RWValueRepresentationItem.hxx

101
src/RWStepRepr/RWStepRepr_RWAllAroundShapeAspect.cxx Normal file
View File

@ -0,0 +1,101 @@
// 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());
}

52
src/RWStepRepr/RWStepRepr_RWAllAroundShapeAspect.hxx Normal file
View File

@ -0,0 +1,52 @@
// 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

101
src/RWStepRepr/RWStepRepr_RWApex.cxx Normal file
View File

@ -0,0 +1,101 @@
// 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());
}

52
src/RWStepRepr/RWStepRepr_RWApex.hxx Normal file
View File

@ -0,0 +1,52 @@
// 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

101
src/RWStepRepr/RWStepRepr_RWBetweenShapeAspect.cxx Normal file
View File

@ -0,0 +1,101 @@
// 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());
}

52
src/RWStepRepr/RWStepRepr_RWBetweenShapeAspect.hxx Normal file
View File

@ -0,0 +1,52 @@
// 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

101
src/RWStepRepr/RWStepRepr_RWCentreOfSymmetry.cxx Normal file
View File

@ -0,0 +1,101 @@
// 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());
}

52
src/RWStepRepr/RWStepRepr_RWCentreOfSymmetry.hxx Normal file
View File

@ -0,0 +1,52 @@
// 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

96
src/RWStepRepr/RWStepRepr_RWCompGroupShAspAndCompShAspAndDatumFeatAndShAsp.cxx Normal file
View File

@ -0,0 +1,96 @@
// 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());
}

47
src/RWStepRepr/RWStepRepr_RWCompGroupShAspAndCompShAspAndDatumFeatAndShAsp.hxx Normal file
View File

@ -0,0 +1,47 @@
// 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

95
src/RWStepRepr/RWStepRepr_RWCompShAspAndDatumFeatAndShAsp.cxx Normal file
View File

@ -0,0 +1,95 @@
// 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());
}

47
src/RWStepRepr/RWStepRepr_RWCompShAspAndDatumFeatAndShAsp.hxx Normal file
View File

@ -0,0 +1,47 @@
// 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

101
src/RWStepRepr/RWStepRepr_RWCompositeGroupShapeAspect.cxx Normal file
View File

@ -0,0 +1,101 @@
// 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());
}

52
src/RWStepRepr/RWStepRepr_RWCompositeGroupShapeAspect.hxx Normal file
View File

@ -0,0 +1,52 @@
// 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

101
src/RWStepRepr/RWStepRepr_RWContinuosShapeAspect.cxx Normal file
View File

@ -0,0 +1,101 @@
// 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());
}

52
src/RWStepRepr/RWStepRepr_RWContinuosShapeAspect.hxx Normal file
View File

@ -0,0 +1,52 @@
// 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

104
src/RWStepRepr/RWStepRepr_RWGeometricAlignment.cxx Normal file
View File

@ -0,0 +1,104 @@
// 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());
}

52
src/RWStepRepr/RWStepRepr_RWGeometricAlignment.hxx Normal file
View File

@ -0,0 +1,52 @@
// 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

54
src/RWStepRepr/RWStepRepr_RWIntegerRepresentationItem.cxx Normal file
View File

@ -0,0 +1,54 @@
// 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());
}

44
src/RWStepRepr/RWStepRepr_RWIntegerRepresentationItem.hxx Normal file
View File

@ -0,0 +1,44 @@
// 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

110
src/RWStepRepr/RWStepRepr_RWParallelOffset.cxx Normal file
View File

@ -0,0 +1,110 @@
// 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());
}

52
src/RWStepRepr/RWStepRepr_RWParallelOffset.hxx Normal file
View File

@ -0,0 +1,52 @@
// 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

101
src/RWStepRepr/RWStepRepr_RWPerpendicularTo.cxx Normal file
View File

@ -0,0 +1,101 @@
// 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());
}

52
src/RWStepRepr/RWStepRepr_RWPerpendicularTo.hxx Normal file
View File

@ -0,0 +1,52 @@
// 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

112
src/RWStepRepr/RWStepRepr_RWReprItemAndLengthMeasureWithUnitAndQRI.cxx Normal file
View File

@ -0,0 +1,112 @@
// 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());
}

44
src/RWStepRepr/RWStepRepr_RWReprItemAndLengthMeasureWithUnitAndQRI.hxx Normal file
View File

@ -0,0 +1,44 @@
// 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

84
src/RWStepRepr/RWStepRepr_RWReprItemAndPlaneAngleMeasureWithUnit.cxx Normal file
View File

@ -0,0 +1,84 @@
// 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());
}

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