StepTidy_PlaneReducer_Test.cxx
StepTidy_Merger_Test.cxx
StepTidy_VectorReducer_Test.cxx
+ StepTransientReplacements_Test.cxx
)
--- /dev/null
+#include <gtest/gtest.h>
+
+#include <Standard_Transient.hxx>
+#include <StepBasic_MeasureWithUnit.hxx>
+#include <StepRepr_ReprItemAndMeasureWithUnit.hxx>
+
+#include <StepBasic_ConversionBasedUnit.hxx>
+#include <StepBasic_DimensionalExponents.hxx>
+#include <StepBasic_SiUnit.hxx>
+#include <StepBasic_MeasureValueMember.hxx>
+#include <StepBasic_SiPrefix.hxx>
+#include <StepBasic_SiUnitName.hxx>
+
+#include <StepDimTol_GeometricTolerance.hxx>
+#include <StepRepr_MakeFromUsageOption.hxx>
+#include <StepRepr_ParallelOffset.hxx>
+#include <StepRepr_QuantifiedAssemblyComponentUsage.hxx>
+#include <StepShape_MeasureQualification.hxx>
+#include <StepData_Logical.hxx>
+#include <StepRepr_ProductDefinitionShape.hxx>
+#include <StepBasic_ProductDefinition.hxx>
+#include <StepDimTol_GeometricToleranceTarget.hxx>
+#include <StepShape_HArray1OfValueQualifier.hxx>
+
+// Helper functions to create test objects
+namespace
+{
+
+// Create a MeasureWithUnit
+Handle(StepBasic_MeasureWithUnit) CreateMeasureWithUnit(const Standard_Real theValue)
+{
+ Handle(StepBasic_MeasureWithUnit) aMeasure = new StepBasic_MeasureWithUnit();
+
+ // Set value component
+ Handle(StepBasic_MeasureValueMember) aValueMember = new StepBasic_MeasureValueMember();
+ aValueMember->SetName("POSITIVE_LENGTH_MEASURE");
+ aValueMember->SetReal(theValue);
+ aMeasure->SetValueComponentMember(aValueMember);
+
+ // Create a dummy SiUnit for unit component
+ Handle(StepBasic_SiUnit) aSiUnit = new StepBasic_SiUnit();
+ aSiUnit->Init(Standard_False,
+ StepBasic_SiPrefix::StepBasic_spMilli,
+ StepBasic_SiUnitName::StepBasic_sunMetre);
+ StepBasic_Unit aUnit;
+ aUnit.SetValue(aSiUnit);
+ aMeasure->SetUnitComponent(aUnit);
+
+ return aMeasure;
+}
+
+// Create a ReprItemAndMeasureWithUnit
+Handle(StepRepr_ReprItemAndMeasureWithUnit) CreateReprItemAndMeasureWithUnit(
+ const Standard_Real theValue)
+{
+ Handle(StepRepr_ReprItemAndMeasureWithUnit) aReprMeasure =
+ new StepRepr_ReprItemAndMeasureWithUnit();
+ Handle(StepBasic_MeasureWithUnit) aMeasure = CreateMeasureWithUnit(theValue);
+ aReprMeasure->SetMeasureWithUnit(aMeasure);
+
+ // Set other required fields
+ Handle(TCollection_HAsciiString) aName = new TCollection_HAsciiString("TestReprItem");
+ aReprMeasure->SetName(aName);
+
+ return aReprMeasure;
+}
+} // namespace
+
+// Test fixture for all transient replacement tests
+class StepTransientReplacements : public ::testing::Test
+{
+protected:
+ void SetUp() override
+ {
+ // Create common test objects
+ myMeasureWithUnit = CreateMeasureWithUnit(5.0);
+ myReprItemAndMeasureWithUnit = CreateReprItemAndMeasureWithUnit(10.0);
+
+ // Create dimensional exponents
+ myDimensionalExponents = new StepBasic_DimensionalExponents();
+ myDimensionalExponents->Init(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
+
+ // Create name string
+ myName = new TCollection_HAsciiString("TestName");
+
+ // Create description string
+ myDescription = new TCollection_HAsciiString("TestDescription");
+
+ // Create product definition
+ myProductDefinition = new StepBasic_ProductDefinition();
+
+ // Create product definition shape
+ myProductDefinitionShape = new StepRepr_ProductDefinitionShape();
+
+ // Create qualifiers array
+ myQualifiers = new StepShape_HArray1OfValueQualifier(1, 1);
+ }
+
+ // Common test objects
+ Handle(StepBasic_MeasureWithUnit) myMeasureWithUnit;
+ Handle(StepRepr_ReprItemAndMeasureWithUnit) myReprItemAndMeasureWithUnit;
+ Handle(StepBasic_DimensionalExponents) myDimensionalExponents;
+ Handle(TCollection_HAsciiString) myName;
+ Handle(TCollection_HAsciiString) myDescription;
+ Handle(StepBasic_ProductDefinition) myProductDefinition;
+ Handle(StepRepr_ProductDefinitionShape) myProductDefinitionShape;
+ Handle(StepShape_HArray1OfValueQualifier) myQualifiers;
+};
+
+// Test ConversionBasedUnit with different transient types
+TEST_F(StepTransientReplacements, ConversionBasedUnit_WorksWithBothTypes)
+{
+ // Create ConversionBasedUnit
+ Handle(StepBasic_ConversionBasedUnit) aUnit = new StepBasic_ConversionBasedUnit();
+
+ // Test with MeasureWithUnit
+ aUnit->Init(myDimensionalExponents, myName, myMeasureWithUnit);
+ EXPECT_FALSE(aUnit->ConversionFactor().IsNull());
+ EXPECT_TRUE(aUnit->ConversionFactor()->IsKind(STANDARD_TYPE(StepBasic_MeasureWithUnit)));
+
+ Handle(StepBasic_MeasureWithUnit) aMeasure =
+ Handle(StepBasic_MeasureWithUnit)::DownCast(aUnit->ConversionFactor());
+ EXPECT_FALSE(aMeasure.IsNull());
+ EXPECT_NEAR(aMeasure->ValueComponent(), 5.0, 1e-7);
+
+ // Test with ReprItemAndMeasureWithUnit
+ aUnit->SetConversionFactor(myReprItemAndMeasureWithUnit);
+ EXPECT_FALSE(aUnit->ConversionFactor().IsNull());
+ EXPECT_TRUE(
+ aUnit->ConversionFactor()->IsKind(STANDARD_TYPE(StepRepr_ReprItemAndMeasureWithUnit)));
+
+ Handle(StepRepr_ReprItemAndMeasureWithUnit) aReprMeasure =
+ Handle(StepRepr_ReprItemAndMeasureWithUnit)::DownCast(aUnit->ConversionFactor());
+ EXPECT_FALSE(aReprMeasure.IsNull());
+ Handle(StepBasic_MeasureWithUnit) aExtractedMeasure = aReprMeasure->GetMeasureWithUnit();
+ EXPECT_NEAR(aExtractedMeasure->ValueComponent(), 10.0, 1e-7);
+}
+
+// Test GeometricTolerance with different transient types
+TEST_F(StepTransientReplacements, GeometricTolerance_WorksWithBothTypes)
+{
+ // Create GeometricTolerance
+ Handle(StepDimTol_GeometricTolerance) aTolerance = new StepDimTol_GeometricTolerance();
+
+ // Create a dummy tolerance target
+ StepDimTol_GeometricToleranceTarget aTarget;
+
+ // Test with MeasureWithUnit
+ aTolerance->Init(myName, myDescription, myMeasureWithUnit, aTarget);
+ EXPECT_FALSE(aTolerance->Magnitude().IsNull());
+ EXPECT_TRUE(aTolerance->Magnitude()->IsKind(STANDARD_TYPE(StepBasic_MeasureWithUnit)));
+
+ Handle(StepBasic_MeasureWithUnit) aMeasure =
+ Handle(StepBasic_MeasureWithUnit)::DownCast(aTolerance->Magnitude());
+ EXPECT_FALSE(aMeasure.IsNull());
+ EXPECT_NEAR(aMeasure->ValueComponent(), 5.0, 1e-7);
+
+ // Test with ReprItemAndMeasureWithUnit
+ aTolerance->SetMagnitude(myReprItemAndMeasureWithUnit);
+ EXPECT_FALSE(aTolerance->Magnitude().IsNull());
+ EXPECT_TRUE(aTolerance->Magnitude()->IsKind(STANDARD_TYPE(StepRepr_ReprItemAndMeasureWithUnit)));
+
+ Handle(StepRepr_ReprItemAndMeasureWithUnit) aReprMeasure =
+ Handle(StepRepr_ReprItemAndMeasureWithUnit)::DownCast(aTolerance->Magnitude());
+ EXPECT_FALSE(aReprMeasure.IsNull());
+ Handle(StepBasic_MeasureWithUnit) aExtractedMeasure = aReprMeasure->GetMeasureWithUnit();
+ EXPECT_NEAR(aExtractedMeasure->ValueComponent(), 10.0, 1e-7);
+}
+
+// Test MakeFromUsageOption with different transient types
+TEST_F(StepTransientReplacements, MakeFromUsageOption_WorksWithBothTypes)
+{
+ // Create MakeFromUsageOption
+ Handle(StepRepr_MakeFromUsageOption) aMakeFromUsage = new StepRepr_MakeFromUsageOption();
+
+ // Test with MeasureWithUnit
+ // Use proper function signature for Init
+ Standard_Boolean hasDescription = Standard_True;
+ aMakeFromUsage->Init(myName,
+ myName,
+ hasDescription,
+ myDescription,
+ myProductDefinition,
+ myProductDefinition,
+ 1,
+ myDescription,
+ myMeasureWithUnit);
+
+ EXPECT_FALSE(aMakeFromUsage->Quantity().IsNull());
+ EXPECT_TRUE(aMakeFromUsage->Quantity()->IsKind(STANDARD_TYPE(StepBasic_MeasureWithUnit)));
+
+ Handle(StepBasic_MeasureWithUnit) aMeasure =
+ Handle(StepBasic_MeasureWithUnit)::DownCast(aMakeFromUsage->Quantity());
+ EXPECT_FALSE(aMeasure.IsNull());
+ EXPECT_NEAR(aMeasure->ValueComponent(), 5.0, 1e-7);
+
+ // Test with ReprItemAndMeasureWithUnit
+ aMakeFromUsage->SetQuantity(myReprItemAndMeasureWithUnit);
+ EXPECT_FALSE(aMakeFromUsage->Quantity().IsNull());
+ EXPECT_TRUE(
+ aMakeFromUsage->Quantity()->IsKind(STANDARD_TYPE(StepRepr_ReprItemAndMeasureWithUnit)));
+
+ Handle(StepRepr_ReprItemAndMeasureWithUnit) aReprMeasure =
+ Handle(StepRepr_ReprItemAndMeasureWithUnit)::DownCast(aMakeFromUsage->Quantity());
+ EXPECT_FALSE(aReprMeasure.IsNull());
+ Handle(StepBasic_MeasureWithUnit) aExtractedMeasure = aReprMeasure->GetMeasureWithUnit();
+ EXPECT_NEAR(aExtractedMeasure->ValueComponent(), 10.0, 1e-7);
+}
+
+// Test ParallelOffset with different transient types
+TEST_F(StepTransientReplacements, ParallelOffset_WorksWithBothTypes)
+{
+ // Create ParallelOffset
+ Handle(StepRepr_ParallelOffset) aParallelOffset = new StepRepr_ParallelOffset();
+
+ // Test with MeasureWithUnit
+ aParallelOffset->Init(myName,
+ myDescription,
+ myProductDefinitionShape,
+ StepData_LTrue,
+ myMeasureWithUnit);
+
+ EXPECT_FALSE(aParallelOffset->Offset().IsNull());
+ EXPECT_TRUE(aParallelOffset->Offset()->IsKind(STANDARD_TYPE(StepBasic_MeasureWithUnit)));
+
+ Handle(StepBasic_MeasureWithUnit) aMeasure =
+ Handle(StepBasic_MeasureWithUnit)::DownCast(aParallelOffset->Offset());
+ EXPECT_FALSE(aMeasure.IsNull());
+ EXPECT_NEAR(aMeasure->ValueComponent(), 5.0, 1e-7);
+
+ // Test with ReprItemAndMeasureWithUnit
+ aParallelOffset->SetOffset(myReprItemAndMeasureWithUnit);
+ EXPECT_FALSE(aParallelOffset->Offset().IsNull());
+ EXPECT_TRUE(
+ aParallelOffset->Offset()->IsKind(STANDARD_TYPE(StepRepr_ReprItemAndMeasureWithUnit)));
+
+ Handle(StepRepr_ReprItemAndMeasureWithUnit) aReprMeasure =
+ Handle(StepRepr_ReprItemAndMeasureWithUnit)::DownCast(aParallelOffset->Offset());
+ EXPECT_FALSE(aReprMeasure.IsNull());
+ Handle(StepBasic_MeasureWithUnit) aExtractedMeasure = aReprMeasure->GetMeasureWithUnit();
+ EXPECT_NEAR(aExtractedMeasure->ValueComponent(), 10.0, 1e-7);
+}
+
+// Test QuantifiedAssemblyComponentUsage with different transient types
+TEST_F(StepTransientReplacements, QuantifiedAssemblyComponentUsage_WorksWithBothTypes)
+{
+ // Create QuantifiedAssemblyComponentUsage
+ Handle(StepRepr_QuantifiedAssemblyComponentUsage) aUsage =
+ new StepRepr_QuantifiedAssemblyComponentUsage();
+
+ // Test with MeasureWithUnit
+ // Use proper function signature for Init
+ Standard_Boolean hasDescription = Standard_True;
+ Standard_Boolean hasReferenceDesignator = Standard_True;
+ aUsage->Init(myName,
+ myName,
+ hasDescription,
+ myDescription,
+ myProductDefinition,
+ myProductDefinition,
+ hasReferenceDesignator,
+ myName,
+ myMeasureWithUnit);
+
+ EXPECT_FALSE(aUsage->Quantity().IsNull());
+ EXPECT_TRUE(aUsage->Quantity()->IsKind(STANDARD_TYPE(StepBasic_MeasureWithUnit)));
+
+ Handle(StepBasic_MeasureWithUnit) aMeasure =
+ Handle(StepBasic_MeasureWithUnit)::DownCast(aUsage->Quantity());
+ EXPECT_FALSE(aMeasure.IsNull());
+ EXPECT_NEAR(aMeasure->ValueComponent(), 5.0, 1e-7);
+
+ // Test with ReprItemAndMeasureWithUnit
+ aUsage->SetQuantity(myReprItemAndMeasureWithUnit);
+ EXPECT_FALSE(aUsage->Quantity().IsNull());
+ EXPECT_TRUE(aUsage->Quantity()->IsKind(STANDARD_TYPE(StepRepr_ReprItemAndMeasureWithUnit)));
+
+ Handle(StepRepr_ReprItemAndMeasureWithUnit) aReprMeasure =
+ Handle(StepRepr_ReprItemAndMeasureWithUnit)::DownCast(aUsage->Quantity());
+ EXPECT_FALSE(aReprMeasure.IsNull());
+ Handle(StepBasic_MeasureWithUnit) aExtractedMeasure = aReprMeasure->GetMeasureWithUnit();
+ EXPECT_NEAR(aExtractedMeasure->ValueComponent(), 10.0, 1e-7);
+}
+
+// Test MeasureQualification with different transient types
+TEST_F(StepTransientReplacements, MeasureQualification_WorksWithBothTypes)
+{
+ // Create MeasureQualification
+ Handle(StepShape_MeasureQualification) aQualification = new StepShape_MeasureQualification();
+
+ // Test with MeasureWithUnit
+ aQualification->Init(myName, myDescription, myMeasureWithUnit, myQualifiers);
+
+ EXPECT_FALSE(aQualification->QualifiedMeasure().IsNull());
+ EXPECT_TRUE(aQualification->QualifiedMeasure()->IsKind(STANDARD_TYPE(StepBasic_MeasureWithUnit)));
+
+ Handle(StepBasic_MeasureWithUnit) aMeasure =
+ Handle(StepBasic_MeasureWithUnit)::DownCast(aQualification->QualifiedMeasure());
+ EXPECT_FALSE(aMeasure.IsNull());
+ EXPECT_NEAR(aMeasure->ValueComponent(), 5.0, 1e-7);
+
+ // Test with ReprItemAndMeasureWithUnit
+ aQualification->SetQualifiedMeasure(myReprItemAndMeasureWithUnit);
+ EXPECT_FALSE(aQualification->QualifiedMeasure().IsNull());
+ EXPECT_TRUE(
+ aQualification->QualifiedMeasure()->IsKind(STANDARD_TYPE(StepRepr_ReprItemAndMeasureWithUnit)));
+
+ Handle(StepRepr_ReprItemAndMeasureWithUnit) aReprMeasure =
+ Handle(StepRepr_ReprItemAndMeasureWithUnit)::DownCast(aQualification->QualifiedMeasure());
+ EXPECT_FALSE(aReprMeasure.IsNull());
+ Handle(StepBasic_MeasureWithUnit) aExtractedMeasure = aReprMeasure->GetMeasureWithUnit();
+ EXPECT_NEAR(aExtractedMeasure->ValueComponent(), 10.0, 1e-7);
+}
+
+// Test GetMeasureWithUnit helper function from STEPCAFControl_Reader namespace
+TEST_F(StepTransientReplacements, GetMeasureWithUnit_ExtractsCorrectly)
+{
+ // This tests the helper function that was added in STEPCAFControl_Reader.cxx
+ // We recreate the function here for testing
+
+ auto GetMeasureWithUnit =
+ [](const Handle(Standard_Transient)& theMeasure) -> Handle(StepBasic_MeasureWithUnit) {
+ if (theMeasure.IsNull())
+ {
+ return nullptr;
+ }
+
+ Handle(StepBasic_MeasureWithUnit) aMeasureWithUnit;
+ if (theMeasure->IsKind(STANDARD_TYPE(StepBasic_MeasureWithUnit)))
+ {
+ aMeasureWithUnit = Handle(StepBasic_MeasureWithUnit)::DownCast(theMeasure);
+ }
+ else if (theMeasure->IsKind(STANDARD_TYPE(StepRepr_ReprItemAndMeasureWithUnit)))
+ {
+ Handle(StepRepr_ReprItemAndMeasureWithUnit) aReprMeasureItem =
+ Handle(StepRepr_ReprItemAndMeasureWithUnit)::DownCast(theMeasure);
+ aMeasureWithUnit = aReprMeasureItem->GetMeasureWithUnit();
+ }
+ return aMeasureWithUnit;
+ };
+
+ // Test with null
+ Handle(Standard_Transient) aNullTransient;
+ Handle(StepBasic_MeasureWithUnit) aExtracted = GetMeasureWithUnit(aNullTransient);
+ EXPECT_TRUE(aExtracted.IsNull());
+
+ // Test with MeasureWithUnit
+ aExtracted = GetMeasureWithUnit(myMeasureWithUnit);
+ EXPECT_FALSE(aExtracted.IsNull());
+ EXPECT_NEAR(aExtracted->ValueComponent(), 5.0, 1e-7);
+
+ // Test with ReprItemAndMeasureWithUnit
+ aExtracted = GetMeasureWithUnit(myReprItemAndMeasureWithUnit);
+ EXPECT_FALSE(aExtracted.IsNull());
+ EXPECT_NEAR(aExtracted->ValueComponent(), 10.0, 1e-7);
+
+ // Test with unrelated type
+ Handle(Standard_Transient) anUnrelatedTransient = myName;
+ aExtracted = GetMeasureWithUnit(anUnrelatedTransient);
+ EXPECT_TRUE(aExtracted.IsNull());
+}
// --- own field : conversionFactor ---
- Handle(StepBasic_MeasureWithUnit) aConversionFactor;
+ Handle(Standard_Transient) aConversionFactor;
// szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
data->ReadEntity(num,
3,
"conversion_factor",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aConversionFactor);
//--- Initialisation of the read entity ---
data->ReadString(num, 1, "name", ach, aName);
// --- field : conversionFactor ---
- Handle(StepBasic_MeasureWithUnit) aConversionFactor;
+ Handle(Standard_Transient) aConversionFactor;
data->ReadEntity(num,
2,
"conversion_factor",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aConversionFactor);
num = data->NextForComplex(num);
// --- field : conversionFactor ---
- Handle(StepBasic_MeasureWithUnit) aConversionFactor;
+ Handle(Standard_Transient) aConversionFactor;
// szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
data->ReadEntity(num,
2,
"conversion_factor",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aConversionFactor);
num = data->NextForComplex(num);
// szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
data->ReadString(num, 1, "name", ach, aName);
// --- field : conversionFactor ---
- Handle(StepBasic_MeasureWithUnit) aConversionFactor;
+ Handle(Standard_Transient) aConversionFactor;
// szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
data->ReadEntity(num,
2,
"conversion_factor",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aConversionFactor);
num = data->NextForComplex(num);
return;
Handle(TCollection_HAsciiString) aName;
data->ReadString(num, 1, "name", ach, aName);
- Handle(StepBasic_MeasureWithUnit) aConversionFactor;
+ Handle(Standard_Transient) aConversionFactor;
data->ReadEntity(num,
2,
"conversion_factor",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aConversionFactor);
// NAMED_UNIT
// --- field : conversionFactor ---
- Handle(StepBasic_MeasureWithUnit) aConversionFactor;
+ Handle(Standard_Transient) aConversionFactor;
// szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
data->ReadEntity(num,
2,
"conversion_factor",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aConversionFactor);
num = data->NextForComplex(num);
// --- field : conversionFactor ---
- Handle(StepBasic_MeasureWithUnit) aConversionFactor;
+ Handle(Standard_Transient) aConversionFactor;
// szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
data->ReadEntity(num,
2,
"conversion_factor",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aConversionFactor);
num = data->NextForComplex(num);
// --- field : conversionFactor ---
- Handle(StepBasic_MeasureWithUnit) aConversionFactor;
+ Handle(Standard_Transient) aConversionFactor;
// szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
data->ReadEntity(num,
2,
"conversion_factor",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aConversionFactor);
num = data->NextForComplex(num);
data->ReadString(num, 1, "name", ach, aName);
// --- field : conversionFactor ---
- Handle(StepBasic_MeasureWithUnit) aConversionFactor;
+ Handle(Standard_Transient) aConversionFactor;
data->ReadEntity(num,
2,
"conversion_factor",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aConversionFactor);
num = data->NextForComplex(num);
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString(num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
- Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
+ Handle(Standard_Transient) aGeometricTolerance_Magnitude;
data->ReadEntity(num,
3,
"geometric_tolerance.magnitude",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aGeometricTolerance_Magnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString(num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
- Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
+ Handle(Standard_Transient) aGeometricTolerance_Magnitude;
data->ReadEntity(num,
3,
"geometric_tolerance.magnitude",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aGeometricTolerance_Magnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString(num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
- Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
+ Handle(Standard_Transient) aGeometricTolerance_Magnitude;
data->ReadEntity(num,
3,
"geometric_tolerance.magnitude",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aGeometricTolerance_Magnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString(num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
- Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
+ Handle(Standard_Transient) aGeometricTolerance_Magnitude;
data->ReadEntity(num,
3,
"geometric_tolerance.magnitude",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aGeometricTolerance_Magnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString(num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
- Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
+ Handle(Standard_Transient) aGeometricTolerance_Magnitude;
data->ReadEntity(num,
3,
"geometric_tolerance.magnitude",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aGeometricTolerance_Magnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString(num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
- Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
+ Handle(Standard_Transient) aGeometricTolerance_Magnitude;
data->ReadEntity(num,
3,
"geometric_tolerance.magnitude",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aGeometricTolerance_Magnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
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);
+ Handle(Standard_Transient) aMagnitude;
+ data->ReadEntity(num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
data->ReadEntity(num, 4, "toleranced_shape_aspect", ach, aTolerancedShapeAspect);
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);
+ Handle(Standard_Transient) aMagnitude;
+ data->ReadEntity(num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
data->ReadEntity(num, 4, "toleranced_shape_aspect", ach, aTolerancedShapeAspect);
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);
+ Handle(Standard_Transient) aMagnitude;
+ data->ReadEntity(num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
data->ReadEntity(num, 4, "toleranced_shape_aspect", ach, aTolerancedShapeAspect);
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);
+ Handle(Standard_Transient) aMagnitude;
+ data->ReadEntity(num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
data->ReadEntity(num, 4, "toleranced_shape_aspect", ach, aTolerancedShapeAspect);
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);
+ Handle(Standard_Transient) aMagnitude;
+ data->ReadEntity(num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
data->ReadEntity(num, 4, "toleranced_shape_aspect", ach, aTolerancedShapeAspect);
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);
+ Handle(Standard_Transient) aMagnitude;
+ data->ReadEntity(num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
data->ReadEntity(num, 4, "toleranced_shape_aspect", ach, aTolerancedShapeAspect);
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);
+ Handle(Standard_Transient) aMagnitude;
+ data->ReadEntity(num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
data->ReadEntity(num, 4, "toleranced_shape_aspect", ach, aTolerancedShapeAspect);
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);
+ Handle(Standard_Transient) aMagnitude;
+ data->ReadEntity(num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
data->ReadEntity(num, 4, "toleranced_shape_aspect", ach, aTolerancedShapeAspect);
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString(num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
- Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
+ Handle(Standard_Transient) aGeometricTolerance_Magnitude;
data->ReadEntity(num,
3,
"geometric_tolerance.magnitude",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aGeometricTolerance_Magnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
Handle(TCollection_HAsciiString) aDescription;
data->ReadString(num, 2, "geometric_tolerance.description", ach, aDescription);
- Handle(StepBasic_MeasureWithUnit) aMagnitude;
+ Handle(Standard_Transient) aMagnitude;
data->ReadEntity(num,
3,
"geometric_tolerance.magnitude",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aMagnitude);
StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
Handle(TCollection_HAsciiString) aDescription;
data->ReadString(num, 2, "geometric_tolerance.description", ach, aDescription);
- Handle(StepBasic_MeasureWithUnit) aMagnitude;
+ Handle(Standard_Transient) aMagnitude;
data->ReadEntity(num,
3,
"geometric_tolerance.magnitude",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aMagnitude);
StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
Handle(TCollection_HAsciiString) aDescription;
data->ReadString(num, 2, "geometric_tolerance.description", ach, aDescription);
- Handle(StepBasic_MeasureWithUnit) aMagnitude;
+ Handle(Standard_Transient) aMagnitude;
data->ReadEntity(num,
3,
"geometric_tolerance.magnitude",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aMagnitude);
StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
Handle(TCollection_HAsciiString) aDescription;
data->ReadString(num, 2, "geometric_tolerance.description", ach, aDescription);
- Handle(StepBasic_MeasureWithUnit) aMagnitude;
+ Handle(Standard_Transient) aMagnitude;
data->ReadEntity(num,
3,
"geometric_tolerance.magnitude",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aMagnitude);
StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString(num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
- Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
+ Handle(Standard_Transient) aGeometricTolerance_Magnitude;
data->ReadEntity(num,
3,
"geometric_tolerance.magnitude",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aGeometricTolerance_Magnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString(num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
- Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
+ Handle(Standard_Transient) aGeometricTolerance_Magnitude;
data->ReadEntity(num,
3,
"geometric_tolerance.magnitude",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aGeometricTolerance_Magnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString(num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
- Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
+ Handle(Standard_Transient) aGeometricTolerance_Magnitude;
data->ReadEntity(num,
3,
"geometric_tolerance.magnitude",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aGeometricTolerance_Magnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString(num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
- Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
+ Handle(Standard_Transient) aGeometricTolerance_Magnitude;
data->ReadEntity(num,
3,
"geometric_tolerance.magnitude",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aGeometricTolerance_Magnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString(num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
- Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
+ Handle(Standard_Transient) aGeometricTolerance_Magnitude;
data->ReadEntity(num,
3,
"geometric_tolerance.magnitude",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aGeometricTolerance_Magnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString(num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
- Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
+ Handle(Standard_Transient) aGeometricTolerance_Magnitude;
data->ReadEntity(num,
3,
"geometric_tolerance.magnitude",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aGeometricTolerance_Magnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString(num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
- Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
+ Handle(Standard_Transient) aGeometricTolerance_Magnitude;
data->ReadEntity(num,
3,
"geometric_tolerance.magnitude",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aGeometricTolerance_Magnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString(num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
- Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
+ Handle(Standard_Transient) aGeometricTolerance_Magnitude;
data->ReadEntity(num,
3,
"geometric_tolerance.magnitude",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aGeometricTolerance_Magnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString(num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
- Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
+ Handle(Standard_Transient) aGeometricTolerance_Magnitude;
data->ReadEntity(num,
3,
"geometric_tolerance.magnitude",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aGeometricTolerance_Magnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString(num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
- Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
+ Handle(Standard_Transient) aGeometricTolerance_Magnitude;
data->ReadEntity(num,
3,
"geometric_tolerance.magnitude",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aGeometricTolerance_Magnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
Handle(TCollection_HAsciiString) aDescription;
data->ReadString(num, 2, "geometric_tolerance.description", ach, aDescription);
- Handle(StepBasic_MeasureWithUnit) aMagnitude;
+ Handle(Standard_Transient) aMagnitude;
data->ReadEntity(num,
3,
"geometric_tolerance.magnitude",
ach,
- STANDARD_TYPE(StepBasic_MeasureWithUnit),
+ STANDARD_TYPE(Standard_Transient),
aMagnitude);
StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
Handle(TCollection_HAsciiString) aRankingRationale;
data->ReadString(num, 7, "ranking_rationale", ach, aRankingRationale);
- Handle(StepBasic_MeasureWithUnit) aQuantity;
- data->ReadEntity(num, 8, "quantity", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aQuantity);
+ Handle(Standard_Transient) aQuantity;
+ data->ReadEntity(num, 8, "quantity", ach, STANDARD_TYPE(Standard_Transient), aQuantity);
// Initialize entity
ent->Init(aProductDefinitionRelationship_Id,
// Own fields of ParallelOffset
- Handle(StepBasic_MeasureWithUnit) anOffset;
- data->ReadEntity(num, 5, "offset", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), anOffset);
+ Handle(Standard_Transient) anOffset;
+ data->ReadEntity(num, 5, "offset", ach, STANDARD_TYPE(Standard_Transient), anOffset);
// Initialize entity
ent->Init(aShapeAspect_Name,
// Own fields of QuantifiedAssemblyComponentUsage
- Handle(StepBasic_MeasureWithUnit) aQuantity;
- data->ReadEntity(num, 7, "quantity", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aQuantity);
+ Handle(Standard_Transient) aQuantity;
+ data->ReadEntity(num, 7, "quantity", ach, STANDARD_TYPE(Standard_Transient), aQuantity);
// Initialize entity
ent->Init(aProductDefinitionRelationship_Id,
// --- own field : qualified_measure ---
- Handle(StepBasic_MeasureWithUnit) aQM;
- data->ReadEntity(num, 3, "qualified_measure", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aQM);
+ Handle(Standard_Transient) aQM;
+ data->ReadEntity(num, 3, "qualified_measure", ach, STANDARD_TYPE(Standard_Transient), aQM);
// --- own field : qualifiers ---
// --- own field : lower_bound ---
- Handle(Standard_Transient) LB;
- if (!data->ReadEntity(num, 1, "lower_bound", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), LB))
- {
- Handle(StepRepr_MeasureRepresentationItem) aMSR;
- Handle(StepRepr_ReprItemAndMeasureWithUnit) aRIMU;
-
- if (data->ReadEntity(num,
- 1,
- "lower_bound",
- ach,
- STANDARD_TYPE(StepRepr_MeasureRepresentationItem),
- aMSR)
- || data->ReadEntity(num,
- 1,
- "lower_bound",
- ach,
- STANDARD_TYPE(StepRepr_ReprItemAndMeasureWithUnit),
- aRIMU))
- {
- if (!aMSR.IsNull())
- LB = aMSR;
- else if (!aRIMU.IsNull())
- LB = aRIMU;
- }
- }
+ Handle(Standard_Transient) aLowerBound;
+ data->ReadEntity(num, 1, "lower_bound", ach, STANDARD_TYPE(Standard_Transient), aLowerBound);
// --- own field : upper_bound ---
- Handle(Standard_Transient) UB;
- if (!data->ReadEntity(num, 2, "upper_bound", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), UB))
- {
- Handle(StepRepr_MeasureRepresentationItem) aMSR1;
- Handle(StepRepr_ReprItemAndMeasureWithUnit) aRIMU1;
- if (data->ReadEntity(num,
- 2,
- "upper_bound",
- ach,
- STANDARD_TYPE(StepRepr_MeasureRepresentationItem),
- aMSR1)
- || data->ReadEntity(num,
- 2,
- "upper_bound",
- ach,
- STANDARD_TYPE(StepRepr_ReprItemAndMeasureWithUnit),
- aRIMU1))
- {
- if (!aMSR1.IsNull())
- UB = aMSR1;
- else if (!aRIMU1.IsNull())
- UB = aRIMU1;
- }
- }
+ Handle(Standard_Transient) anUpperBound;
+ data->ReadEntity(num, 2, "upper_bound", ach, STANDARD_TYPE(Standard_Transient), anUpperBound);
//--- Initialisation of the read entity ---
- if (!LB.IsNull() && !UB.IsNull())
+ if (!aLowerBound.IsNull() && !anUpperBound.IsNull())
ach->ClearFails();
- ent->Init(LB, UB);
+ ent->Init(aLowerBound, anUpperBound);
}
void RWStepShape_RWToleranceValue::WriteStep(StepData_StepWriter& SW,
#include <Bnd_Box.hxx>
#include <BRepBndLib.hxx>
-// skl 21.08.2003 for reading G&DT
-// #include <StepRepr_CompoundItemDefinition.hxx>
-// #include <StepRepr_CompoundItemDefinitionMember.hxx>
-// #include <StepBasic_ConversionBasedUnit.hxx>
-// #include <TDataStd_Real.hxx>
-// #include <TDataStd_Constraint.hxx>
-// #include <TDataStd_ConstraintEnum.hxx>
-// #include <TNaming_Tool.hxx>
-// #include <AIS_InteractiveObject.hxx>
-// #include <TPrsStd_ConstraintTools.hxx>
-// #include <AIS_DiameterDimension.hxx>
-// #include <TPrsStd_Position.hxx>
-// #include <TPrsStd_AISPresentation.hxx>
-// #include <TNaming_Builder.hxx>
-#ifdef OCCT_DEBUG
-//! Converts address of the passed shape (TShape) to string.
-//! \param theShape [in] Shape to dump.
-//! \return corresponding string.
-TCollection_AsciiString AddrToString(const TopoDS_Shape& theShape)
+namespace
{
- std::string anAddrStr;
- std::ostringstream ost;
- ost << theShape.TShape().get();
- anAddrStr = ost.str();
-
- TCollection_AsciiString aStr = TCollection_AsciiString("[").Cat(anAddrStr.c_str()).Cat("]");
+// Returns a MeasureWithUnit from the given Standard_Transient object.
+// If the object is a StepRepr_ReprItemAndMeasureWithUnit, it retrieves
+// the MeasureWithUnit from it. If it is a StepBasic_MeasureWithUnit,
+// it returns it directly. If the object is neither, it returns a null handle.
+// @param theMeasure The Standard_Transient object to check.
+// @return Handle to StepBasic_MeasureWithUnit if found, otherwise null handle.
+static Handle(StepBasic_MeasureWithUnit) GetMeasureWithUnit(
+ const Handle(Standard_Transient)& theMeasure)
+{
+ if (theMeasure.IsNull())
+ {
+ return nullptr;
+ }
- return aStr;
+ Handle(StepBasic_MeasureWithUnit) aMeasureWithUnit;
+ if (theMeasure->IsKind(STANDARD_TYPE(StepBasic_MeasureWithUnit)))
+ {
+ aMeasureWithUnit = Handle(StepBasic_MeasureWithUnit)::DownCast(theMeasure);
+ }
+ else if (theMeasure->IsKind(STANDARD_TYPE(StepRepr_ReprItemAndMeasureWithUnit)))
+ {
+ Handle(StepRepr_ReprItemAndMeasureWithUnit) aReprMeasureItem =
+ Handle(StepRepr_ReprItemAndMeasureWithUnit)::DownCast(theMeasure);
+ aMeasureWithUnit = aReprMeasureItem->GetMeasureWithUnit();
+ }
+ return aMeasureWithUnit;
}
-#endif
+} // namespace
//=================================================================================================
{
if (style != aHSeqOfInvisStyle->Value(si))
continue;
- // found that current style is invisible.
+ // found that current style is invisible.
#ifdef OCCT_DEBUG
std::cout << "Warning: item No " << i << "(" << style->Item()->DynamicType()->Name()
<< ") is invisible" << std::endl;
return Standard_False;
Handle(StepBasic_ConversionBasedUnitAndMassUnit) CBUMU =
Handle(StepBasic_ConversionBasedUnitAndMassUnit)::DownCast(NU);
- Handle(StepBasic_MeasureWithUnit) MWUCBU = CBUMU->ConversionFactor();
+ Handle(StepBasic_MeasureWithUnit) MWUCBU = GetMeasureWithUnit(CBUMU->ConversionFactor());
afact = MWUCBU->ValueComponent();
StepBasic_Unit anUnit2 = MWUCBU->UnitComponent();
if (anUnit2.CaseNum(anUnit2.Value()) == 1)
Handle(StepDimTol_GeometricTolerance) GT =
Handle(StepDimTol_GeometricTolerance)::DownCast(theEnt);
// read common data for tolerance
- // Standard_Real dim = GT->Magnitude()->ValueComponent();
- Handle(StepBasic_MeasureWithUnit) dim3 = GT->Magnitude();
+ Handle(StepBasic_MeasureWithUnit) dim3 = GetMeasureWithUnit(GT->Magnitude());
if (dim3.IsNull())
continue;
Standard_Real dim = dim3->ValueComponent();
- StepBasic_Unit anUnit = GT->Magnitude()->UnitComponent();
+ StepBasic_Unit anUnit = dim3->UnitComponent();
if (anUnit.IsNull())
continue;
if (!(anUnit.CaseNum(anUnit.Value()) == 1))
Handle(Standard_Transient) aUpperBound = aTV->UpperBound();
if (aUpperBound.IsNull())
continue;
- Handle(StepBasic_MeasureWithUnit) aMWU;
- if (aUpperBound->IsKind(STANDARD_TYPE(StepBasic_MeasureWithUnit)))
- aMWU = Handle(StepBasic_MeasureWithUnit)::DownCast(aUpperBound);
- else if (aUpperBound->IsKind(STANDARD_TYPE(StepRepr_ReprItemAndMeasureWithUnit)))
- {
- Handle(StepRepr_ReprItemAndMeasureWithUnit) aReprMeasureItem =
- Handle(StepRepr_ReprItemAndMeasureWithUnit)::DownCast(aUpperBound);
- aMWU = aReprMeasureItem->GetMeasureWithUnit();
- }
+ Handle(StepBasic_MeasureWithUnit) aMWU = GetMeasureWithUnit(aUpperBound);
if (aMWU.IsNull())
continue;
Standard_Real aVal = aMWU->ValueComponent();
if (aLowerBound.IsNull())
continue;
- if (aLowerBound->IsKind(STANDARD_TYPE(StepBasic_MeasureWithUnit)))
- aMWU = Handle(StepBasic_MeasureWithUnit)::DownCast(aLowerBound);
- else if (aLowerBound->IsKind(STANDARD_TYPE(StepRepr_ReprItemAndMeasureWithUnit)))
- {
- Handle(StepRepr_ReprItemAndMeasureWithUnit) aReprMeasureItem =
- Handle(StepRepr_ReprItemAndMeasureWithUnit)::DownCast(aLowerBound);
- aMWU = aReprMeasureItem->GetMeasureWithUnit();
- }
+ aMWU = GetMeasureWithUnit(aLowerBound);
if (aMWU.IsNull())
continue;
if (!aTolEnt->Magnitude().IsNull())
{
// get value
- Standard_Real aVal = aTolEnt->Magnitude()->ValueComponent();
- StepBasic_Unit anUnit = aTolEnt->Magnitude()->UnitComponent();
- if (anUnit.IsNull())
- return;
- if (!(anUnit.CaseNum(anUnit.Value()) == 1))
- return;
- Handle(StepBasic_NamedUnit) NU = anUnit.NamedUnit();
- STEPConstruct_UnitContext anUnitCtx;
- anUnitCtx.ComputeFactors(NU, theLocalFactors);
- aVal = aVal * anUnitCtx.LengthFactor();
- aTolObj->SetValue(aVal);
+ if (Handle(StepBasic_MeasureWithUnit) aMWU = GetMeasureWithUnit(aTolEnt->Magnitude()))
+ {
+ Standard_Real aVal = aMWU->ValueComponent();
+ StepBasic_Unit anUnit = aMWU->UnitComponent();
+ if (anUnit.IsNull())
+ return;
+ if (!(anUnit.CaseNum(anUnit.Value()) == 1))
+ return;
+ Handle(StepBasic_NamedUnit) NU = anUnit.NamedUnit();
+ STEPConstruct_UnitContext anUnitCtx;
+ anUnitCtx.ComputeFactors(NU, theLocalFactors);
+ aVal = aVal * anUnitCtx.LengthFactor();
+ aTolObj->SetValue(aVal);
+ }
}
// get modifiers
XCAFDimTolObjects_GeomToleranceTypeValue aTypeV = XCAFDimTolObjects_GeomToleranceTypeValue_None;
#include <StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx.hxx>
#include <StepRepr_GlobalUncertaintyAssignedContext.hxx>
#include <StepRepr_GlobalUnitAssignedContext.hxx>
+#include <StepRepr_ReprItemAndMeasureWithUnit.hxx>
#include <TCollection_HAsciiString.hxx>
//=================================================================================================
if (aContext.IsNull())
{
-#ifdef OCCT_DEBUG
- std::cout << " -- STEPConstruct_UnitContext:ComputeFactor, Context undefined -> default"
- << std::endl;
-#endif
return 1;
}
{
Handle(StepBasic_NamedUnit) theNamedUnit = aContext->UnitsValue(i);
status = ComputeFactors(theNamedUnit, theLocalFactors);
-#ifdef OCCT_DEBUG
- if (status == -1)
- std::cout << " -- STEPConstruct_UnitContext:ComputeFactor: Unit item no." << i
- << " is not recognized" << std::endl;
-#endif
}
return status;
}
+//=================================================================================================
+
Standard_Integer STEPConstruct_UnitContext::ComputeFactors(const Handle(StepBasic_NamedUnit)& aUnit,
const StepData_Factors& theLocalFactors)
{
{
Handle(StepBasic_ConversionBasedUnit) theCBU =
Handle(StepBasic_ConversionBasedUnit)::DownCast(aUnit);
- // Handle(StepBasic_DimensionalExponents) theDimExp = theCBU->Dimensions();
- Handle(StepBasic_MeasureWithUnit) theMWU;
+
+ Handle(StepBasic_MeasureWithUnit) aMWU;
if (!theCBU.IsNull())
{
- theMWU = theCBU->ConversionFactor();
+ Handle(Standard_Transient) aConvFactor = theCBU->ConversionFactor();
+ if (aConvFactor->IsKind(STANDARD_TYPE(StepBasic_MeasureWithUnit)))
+ {
+ aMWU = Handle(StepBasic_MeasureWithUnit)::DownCast(aConvFactor);
+ }
+ else if (aConvFactor->IsKind(STANDARD_TYPE(StepRepr_ReprItemAndMeasureWithUnit)))
+ {
+ Handle(StepRepr_ReprItemAndMeasureWithUnit) aReprMeasureItem =
+ Handle(StepRepr_ReprItemAndMeasureWithUnit)::DownCast(aConvFactor);
+ aMWU = aReprMeasureItem->GetMeasureWithUnit();
+ }
+
// sln 8.10.2001: the case of unrecognized entity
- if (theMWU.IsNull())
+ if (aMWU.IsNull())
+ {
return -1;
- // if (!theMWU->IsKind(STANDARD_TYPE(StepBasic_LengthMeasureWithUnit))) { gka
- // return 2;
- // }
- Handle(StepBasic_NamedUnit) theTargetUnit = theMWU->UnitComponent().NamedUnit();
- // StepBasic_Unit theTargetUnit = theMWU->UnitComponent();
- Standard_Real theSIPFactor = 1.;
+ }
+
+ Handle(StepBasic_NamedUnit) theTargetUnit = aMWU->UnitComponent().NamedUnit();
+ Standard_Real theSIPFactor = 1.;
//: f5 abv 24 Apr 98: ProSTEP TR8 tr8_bv1_tc: INCHES
- // gka Handle(StepBasic_SiUnitAndLengthUnit) theSUALU =
- // Handle(StepBasic_SiUnitAndLengthUnit)::DownCast(theTargetUnit);
- // Handle(StepBasic_SiUnit) theSIU;
- // if ( ! theSUALU.IsNull() ) theSIU = Handle(StepBasic_SiUnit)::DownCast(theSUALU);
- Handle(StepBasic_SiUnit) theSIU = // f5
- Handle(StepBasic_SiUnit)::DownCast(theTargetUnit); // f5
+ Handle(StepBasic_SiUnit) theSIU = Handle(StepBasic_SiUnit)::DownCast(theTargetUnit);
if (!theSIU.IsNull())
{
// Treat the SiUnitName
if (!SiUnitNameFactor(theSIU, theSIUNF))
status = 11; // et continue
- // std::cout << "The SiUnitNameFactor is :";
- // std::cout << theSIUNF << std::endl;
}
else
{
- // std::cout << "Recursive algo required - Aborted" << std::endl;
return 3;
}
- Standard_Real theMVAL = theMWU->ValueComponent();
+ Standard_Real theMVAL = aMWU->ValueComponent();
theFactor = theSIPFactor * theMVAL; // * theSIUNF * pow(10.,theLExp)
}
parameter = theFactor;
else
{
status = 14;
-#ifdef OCCT_DEBUG
- std::cout << "Error in the file : parameter double defined" << std::endl;
-#endif
}
}
else if (aUnit->IsKind(STANDARD_TYPE(StepBasic_SiUnit)))
else
{
status = 14;
-#ifdef OCCT_DEBUG
- std::cout << "Error in the file : parameter double defined" << std::endl;
-#endif
}
}
// Defining a type of unit
if (!parameterDone)
{
-#ifdef OCCT_DEBUG
- std::cout << "Unit Type not implemented" << std::endl;
-#endif
return 0;
}
else
{
status = 14;
-#ifdef OCCT_DEBUG
- std::cout << "Error in the file : LengthFactor double defined" << std::endl;
-#endif
}
} // end of LengthUnit
else if (aUnit->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndPlaneAngleUnit))
Handle(StepBasic_UncertaintyMeasureWithUnit) aUMWU = aContext->UncertaintyValue(un);
if (aUMWU.IsNull())
{
-#ifdef OCCT_DEBUG
- std::cout << "BAD Uncertainty Measure with Units, n0." << un << std::endl;
-#endif
continue;
}
// Decode the associated Unit
}
}
-#ifdef OCCT_DEBUG
- if (hasUncertainty)
- std::cout << "UNCERTAINTY read as " << theUncertainty << std::endl;
-#endif
return status;
}
#include <StepRepr_RepresentationMap.hxx>
#include <StepRepr_RepresentationRelationship.hxx>
#include <StepRepr_ShapeAspect.hxx>
+#include <StepRepr_ReprItemAndMeasureWithUnit.hxx>
#include <StepShape_ManifoldSolidBrep.hxx>
#include <StepShape_ShapeDefinitionRepresentation.hxx>
#include <StepShape_ShapeRepresentation.hxx>
Standard_Real anUnitFact = 0;
if (!aConvUnit.IsNull())
{
- Handle(StepBasic_MeasureWithUnit) aMeasWithUnit = aConvUnit->ConversionFactor();
+ Handle(StepBasic_MeasureWithUnit) aMeasWithUnit;
+ Handle(Standard_Transient) aConvFactor = aConvUnit->ConversionFactor();
+ if (aConvFactor->IsKind(STANDARD_TYPE(StepBasic_MeasureWithUnit)))
+ {
+ aMeasWithUnit = Handle(StepBasic_MeasureWithUnit)::DownCast(aConvFactor);
+ }
+ else if (aConvFactor->IsKind(STANDARD_TYPE(StepRepr_ReprItemAndMeasureWithUnit)))
+ {
+ Handle(StepRepr_ReprItemAndMeasureWithUnit) aReprMeasureItem =
+ Handle(StepRepr_ReprItemAndMeasureWithUnit)::DownCast(aConvFactor);
+ aMeasWithUnit = aReprMeasureItem->GetMeasureWithUnit();
+ }
if (aMeasWithUnit.IsNull())
continue;
void StepBasic_ConversionBasedUnit::Init(const Handle(StepBasic_DimensionalExponents)& aDimensions,
const Handle(TCollection_HAsciiString)& aName,
- const Handle(StepBasic_MeasureWithUnit)& aConversionFactor)
+ const Handle(Standard_Transient)& aConversionFactor)
{
// --- classe own fields ---
name = aName;
}
void StepBasic_ConversionBasedUnit::SetConversionFactor(
- const Handle(StepBasic_MeasureWithUnit)& aConversionFactor)
+ const Handle(Standard_Transient)& aConversionFactor)
{
conversionFactor = aConversionFactor;
}
-Handle(StepBasic_MeasureWithUnit) StepBasic_ConversionBasedUnit::ConversionFactor() const
+Handle(Standard_Transient) StepBasic_ConversionBasedUnit::ConversionFactor() const
{
return conversionFactor;
}
Standard_EXPORT void Init(const Handle(StepBasic_DimensionalExponents)& aDimensions,
const Handle(TCollection_HAsciiString)& aName,
- const Handle(StepBasic_MeasureWithUnit)& aConversionFactor);
+ const Handle(Standard_Transient)& aConversionFactor);
Standard_EXPORT void SetName(const Handle(TCollection_HAsciiString)& aName);
Standard_EXPORT Handle(TCollection_HAsciiString) Name() const;
- Standard_EXPORT void SetConversionFactor(
- const Handle(StepBasic_MeasureWithUnit)& aConversionFactor);
+ Standard_EXPORT void SetConversionFactor(const Handle(Standard_Transient)& aConversionFactor);
- Standard_EXPORT Handle(StepBasic_MeasureWithUnit) ConversionFactor() const;
+ Standard_EXPORT Handle(Standard_Transient) ConversionFactor() const;
DEFINE_STANDARD_RTTIEXT(StepBasic_ConversionBasedUnit, StepBasic_NamedUnit)
protected:
private:
- Handle(TCollection_HAsciiString) name;
- Handle(StepBasic_MeasureWithUnit) conversionFactor;
+ Handle(TCollection_HAsciiString) name;
+ Handle(Standard_Transient) conversionFactor;
};
#endif // _StepBasic_ConversionBasedUnit_HeaderFile
void StepBasic_ConversionBasedUnitAndLengthUnit::Init(
const Handle(StepBasic_DimensionalExponents)& aDimensions,
const Handle(TCollection_HAsciiString)& aName,
- const Handle(StepBasic_MeasureWithUnit)& aConversionFactor)
+ const Handle(Standard_Transient)& aConversionFactor)
{
// --- ANDOR component fields ---
StepBasic_ConversionBasedUnit::Init(aDimensions, aName, aConversionFactor);
Standard_EXPORT void Init(const Handle(StepBasic_DimensionalExponents)& aDimensions,
const Handle(TCollection_HAsciiString)& aName,
- const Handle(StepBasic_MeasureWithUnit)& aConversionFactor);
+ const Handle(Standard_Transient)& aConversionFactor);
Standard_EXPORT void SetLengthUnit(const Handle(StepBasic_LengthUnit)& aLengthUnit);
void StepBasic_ConversionBasedUnitAndMassUnit::Init(
const Handle(StepBasic_DimensionalExponents)& aDimensions,
const Handle(TCollection_HAsciiString)& aName,
- const Handle(StepBasic_MeasureWithUnit)& aConversionFactor)
+ const Handle(Standard_Transient)& aConversionFactor)
{
// --- ANDOR component fields ---
StepBasic_ConversionBasedUnit::Init(aDimensions, aName, aConversionFactor);
Standard_EXPORT void Init(const Handle(StepBasic_DimensionalExponents)& aDimensions,
const Handle(TCollection_HAsciiString)& aName,
- const Handle(StepBasic_MeasureWithUnit)& aConversionFactor);
+ const Handle(Standard_Transient)& aConversionFactor);
Standard_EXPORT void SetMassUnit(const Handle(StepBasic_MassUnit)& aMassUnit);
void StepBasic_ConversionBasedUnitAndPlaneAngleUnit::Init(
const Handle(StepBasic_DimensionalExponents)& aDimensions,
const Handle(TCollection_HAsciiString)& aName,
- const Handle(StepBasic_MeasureWithUnit)& aConversionFactor)
+ const Handle(Standard_Transient)& aConversionFactor)
{
// --- ANDOR component fields ---
StepBasic_ConversionBasedUnit::Init(aDimensions, aName, aConversionFactor);
Standard_EXPORT void Init(const Handle(StepBasic_DimensionalExponents)& aDimensions,
const Handle(TCollection_HAsciiString)& aName,
- const Handle(StepBasic_MeasureWithUnit)& aConversionFactor);
+ const Handle(Standard_Transient)& aConversionFactor);
Standard_EXPORT void SetPlaneAngleUnit(const Handle(StepBasic_PlaneAngleUnit)& aPlaneAngleUnit);
void StepBasic_ConversionBasedUnitAndRatioUnit::Init(
const Handle(StepBasic_DimensionalExponents)& aDimensions,
const Handle(TCollection_HAsciiString)& aName,
- const Handle(StepBasic_MeasureWithUnit)& aConversionFactor)
+ const Handle(Standard_Transient)& aConversionFactor)
{
// --- ANDOR component fields ---
StepBasic_ConversionBasedUnit::Init(aDimensions, aName, aConversionFactor);
Standard_EXPORT void Init(const Handle(StepBasic_DimensionalExponents)& aDimensions,
const Handle(TCollection_HAsciiString)& aName,
- const Handle(StepBasic_MeasureWithUnit)& aConversionFactor);
+ const Handle(Standard_Transient)& aConversionFactor);
Standard_EXPORT void SetRatioUnit(const Handle(StepBasic_RatioUnit)& aRatioUnit);
void StepBasic_ConversionBasedUnitAndSolidAngleUnit::Init(
const Handle(StepBasic_DimensionalExponents)& aDimensions,
const Handle(TCollection_HAsciiString)& aName,
- const Handle(StepBasic_MeasureWithUnit)& aConversionFactor)
+ const Handle(Standard_Transient)& aConversionFactor)
{
// --- ANDOR component fields ---
StepBasic_ConversionBasedUnit::Init(aDimensions, aName, aConversionFactor);
Standard_EXPORT void Init(const Handle(StepBasic_DimensionalExponents)& aDimensions,
const Handle(TCollection_HAsciiString)& aName,
- const Handle(StepBasic_MeasureWithUnit)& aConversionFactor);
+ const Handle(Standard_Transient)& aConversionFactor);
Standard_EXPORT void SetSolidAngleUnit(const Handle(StepBasic_SolidAngleUnit)& aSolidAngleUnit);
void StepBasic_ConversionBasedUnitAndTimeUnit::Init(
const Handle(StepBasic_DimensionalExponents)& aDimensions,
const Handle(TCollection_HAsciiString)& aName,
- const Handle(StepBasic_MeasureWithUnit)& aConversionFactor)
+ const Handle(Standard_Transient)& aConversionFactor)
{
// --- ANDOR component fields ---
StepBasic_ConversionBasedUnit::Init(aDimensions, aName, aConversionFactor);
Standard_EXPORT void Init(const Handle(StepBasic_DimensionalExponents)& aDimensions,
const Handle(TCollection_HAsciiString)& aName,
- const Handle(StepBasic_MeasureWithUnit)& aConversionFactor);
+ const Handle(Standard_Transient)& aConversionFactor);
Standard_EXPORT void SetTimeUnit(const Handle(StepBasic_TimeUnit)& aTimeUnit);
void StepDimTol_GeoTolAndGeoTolWthDatRef::Init(
const Handle(TCollection_HAsciiString)& theName,
const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(Standard_Transient)& theMagnitude,
const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithDatumReference)& theGTWDR,
const StepDimTol_GeometricToleranceType theType)
void StepDimTol_GeoTolAndGeoTolWthDatRef::Init(
const Handle(TCollection_HAsciiString)& theName,
const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(Standard_Transient)& theMagnitude,
const StepDimTol_GeometricToleranceTarget& theTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithDatumReference)& theGTWDR,
const StepDimTol_GeometricToleranceType theType)
class StepDimTol_GeometricToleranceTarget;
class StepDimTol_GeometricToleranceWithDatumReference;
class TCollection_HAsciiString;
-class StepBasic_MeasureWithUnit;
class StepRepr_ShapeAspect;
class StepDimTol_GeoTolAndGeoTolWthDatRef;
public:
Standard_EXPORT StepDimTol_GeoTolAndGeoTolWthDatRef();
- Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theName,
- const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
- const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theName,
+ const Handle(TCollection_HAsciiString)& theDescription,
+ const Handle(Standard_Transient)& theMagnitude,
+ const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithDatumReference)& theGTWDR,
const StepDimTol_GeometricToleranceType theType);
Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& aName,
const Handle(TCollection_HAsciiString)& aDescription,
- const Handle(StepBasic_MeasureWithUnit)& aMagnitude,
+ const Handle(Standard_Transient)& aMagnitude,
const StepDimTol_GeometricToleranceTarget& aTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithDatumReference)& aGTWDR,
const StepDimTol_GeometricToleranceType theType);
void StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMaxTol::Init(
const Handle(TCollection_HAsciiString)& theName,
const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(Standard_Transient)& theMagnitude,
const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithDatumReference)& theGTWDR,
const Handle(StepDimTol_GeometricToleranceWithModifiers)& theGTWM,
void StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMaxTol::Init(
const Handle(TCollection_HAsciiString)& theName,
const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(Standard_Transient)& theMagnitude,
const StepDimTol_GeometricToleranceTarget& theTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithDatumReference)& theGTWDR,
const Handle(StepDimTol_GeometricToleranceWithModifiers)& theGTWM,
class StepDimTol_GeometricToleranceWithModifiers;
class TCollection_HAsciiString;
class StepBasic_LengthMeasureWithUnit;
-class StepBasic_MeasureWithUnit;
class StepRepr_ShapeAspect;
DEFINE_STANDARD_HANDLE(StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMaxTol,
public:
Standard_EXPORT StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMaxTol();
- Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theName,
- const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
- const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theName,
+ const Handle(TCollection_HAsciiString)& theDescription,
+ const Handle(Standard_Transient)& theMagnitude,
+ const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithDatumReference)& theGTWDR,
const Handle(StepDimTol_GeometricToleranceWithModifiers)& theGTWM,
const Handle(StepBasic_LengthMeasureWithUnit)& theMaxTol,
Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& aName,
const Handle(TCollection_HAsciiString)& aDescription,
- const Handle(StepBasic_MeasureWithUnit)& aMagnitude,
+ const Handle(Standard_Transient)& aMagnitude,
const StepDimTol_GeometricToleranceTarget& aTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithDatumReference)& aGTWDR,
const Handle(StepDimTol_GeometricToleranceWithModifiers)& aGTWM,
void StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod::Init(
const Handle(TCollection_HAsciiString)& theName,
const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(Standard_Transient)& theMagnitude,
const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithDatumReference)& theGTWDR,
const Handle(StepDimTol_GeometricToleranceWithModifiers)& theGTWM,
void StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod::Init(
const Handle(TCollection_HAsciiString)& theName,
const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(Standard_Transient)& theMagnitude,
const StepDimTol_GeometricToleranceTarget& theTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithDatumReference)& theGTWDR,
const Handle(StepDimTol_GeometricToleranceWithModifiers)& theGTWM,
class StepDimTol_GeometricToleranceWithDatumReference;
class StepDimTol_GeometricToleranceWithModifiers;
class TCollection_HAsciiString;
-class StepBasic_MeasureWithUnit;
class StepRepr_ShapeAspect;
class StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod;
public:
Standard_EXPORT StepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod();
- Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theName,
- const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
- const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theName,
+ const Handle(TCollection_HAsciiString)& theDescription,
+ const Handle(Standard_Transient)& theMagnitude,
+ const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithDatumReference)& theGTWDR,
const Handle(StepDimTol_GeometricToleranceWithModifiers)& theGTWM,
const StepDimTol_GeometricToleranceType theType);
Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& aName,
const Handle(TCollection_HAsciiString)& aDescription,
- const Handle(StepBasic_MeasureWithUnit)& aMagnitude,
+ const Handle(Standard_Transient)& aMagnitude,
const StepDimTol_GeometricToleranceTarget& aTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithDatumReference)& aGTWDR,
const Handle(StepDimTol_GeometricToleranceWithModifiers)& aGTWM,
void StepDimTol_GeoTolAndGeoTolWthDatRefAndModGeoTolAndPosTol::Init(
const Handle(TCollection_HAsciiString)& aName,
const Handle(TCollection_HAsciiString)& aDescription,
- const Handle(StepBasic_MeasureWithUnit)& aMagnitude,
+ const Handle(Standard_Transient)& aMagnitude,
const Handle(StepRepr_ShapeAspect)& aTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithDatumReference)& aGTWDR,
const Handle(StepDimTol_ModifiedGeometricTolerance)& aMGT)
void StepDimTol_GeoTolAndGeoTolWthDatRefAndModGeoTolAndPosTol::Init(
const Handle(TCollection_HAsciiString)& aName,
const Handle(TCollection_HAsciiString)& aDescription,
- const Handle(StepBasic_MeasureWithUnit)& aMagnitude,
+ const Handle(Standard_Transient)& aMagnitude,
const StepDimTol_GeometricToleranceTarget& aTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithDatumReference)& aGTWDR,
const Handle(StepDimTol_ModifiedGeometricTolerance)& aMGT)
class StepDimTol_ModifiedGeometricTolerance;
class StepDimTol_PositionTolerance;
class TCollection_HAsciiString;
-class StepBasic_MeasureWithUnit;
class StepRepr_ShapeAspect;
class StepDimTol_GeoTolAndGeoTolWthDatRefAndModGeoTolAndPosTol;
public:
Standard_EXPORT StepDimTol_GeoTolAndGeoTolWthDatRefAndModGeoTolAndPosTol();
- Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& aName,
- const Handle(TCollection_HAsciiString)& aDescription,
- const Handle(StepBasic_MeasureWithUnit)& aMagnitude,
- const Handle(StepRepr_ShapeAspect)& aTolerancedShapeAspect,
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& aName,
+ const Handle(TCollection_HAsciiString)& aDescription,
+ const Handle(Standard_Transient)& aMagnitude,
+ const Handle(StepRepr_ShapeAspect)& aTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithDatumReference)& aGTWDR,
const Handle(StepDimTol_ModifiedGeometricTolerance)& aMGT);
Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& aName,
const Handle(TCollection_HAsciiString)& aDescription,
- const Handle(StepBasic_MeasureWithUnit)& aMagnitude,
+ const Handle(Standard_Transient)& aMagnitude,
const StepDimTol_GeometricToleranceTarget& aTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithDatumReference)& aGTWDR,
const Handle(StepDimTol_ModifiedGeometricTolerance)& aMGT);
void StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol::Init(
const Handle(TCollection_HAsciiString)& theName,
const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(Standard_Transient)& theMagnitude,
const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithDatumReference)& theGTWDR,
const StepDimTol_GeometricToleranceType theType,
void StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol::Init(
const Handle(TCollection_HAsciiString)& theName,
const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(Standard_Transient)& theMagnitude,
const StepDimTol_GeometricToleranceTarget& theTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithDatumReference)& theGTWDR,
const StepDimTol_GeometricToleranceType theType,
class StepDimTol_GeometricToleranceWithDatumReference;
class StepDimTol_UnequallyDisposedGeometricTolerance;
class TCollection_HAsciiString;
-class StepBasic_MeasureWithUnit;
class StepRepr_ShapeAspect;
class StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol;
public:
Standard_EXPORT StepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol();
- Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theName,
- const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
- const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theName,
+ const Handle(TCollection_HAsciiString)& theDescription,
+ const Handle(Standard_Transient)& theMagnitude,
+ const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithDatumReference)& theGTWDR,
const StepDimTol_GeometricToleranceType theType,
const Handle(StepDimTol_UnequallyDisposedGeometricTolerance)& theUDGT);
Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& aName,
const Handle(TCollection_HAsciiString)& aDescription,
- const Handle(StepBasic_MeasureWithUnit)& aMagnitude,
+ const Handle(Standard_Transient)& aMagnitude,
const StepDimTol_GeometricToleranceTarget& aTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithDatumReference)& aGTWDR,
const StepDimTol_GeometricToleranceType theType,
void StepDimTol_GeoTolAndGeoTolWthMaxTol::Init(
const Handle(TCollection_HAsciiString)& theName,
const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(Standard_Transient)& theMagnitude,
const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithModifiers)& theGTWM,
const Handle(StepBasic_LengthMeasureWithUnit)& theMaxTol,
void StepDimTol_GeoTolAndGeoTolWthMaxTol::Init(
const Handle(TCollection_HAsciiString)& theName,
const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(Standard_Transient)& theMagnitude,
const StepDimTol_GeometricToleranceTarget& theTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithModifiers)& theGTWM,
const Handle(StepBasic_LengthMeasureWithUnit)& theMaxTol,
class StepDimTol_GeometricToleranceWithModifiers;
class TCollection_HAsciiString;
class StepBasic_LengthMeasureWithUnit;
-class StepBasic_MeasureWithUnit;
class StepRepr_ShapeAspect;
class StepDimTol_GeoTolAndGeoTolWthMaxTol;
public:
Standard_EXPORT StepDimTol_GeoTolAndGeoTolWthMaxTol();
- Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theName,
- const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
- const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theName,
+ const Handle(TCollection_HAsciiString)& theDescription,
+ const Handle(Standard_Transient)& theMagnitude,
+ const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithModifiers)& theGTWM,
const Handle(StepBasic_LengthMeasureWithUnit)& theMaxTol,
const StepDimTol_GeometricToleranceType theType);
Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& aName,
const Handle(TCollection_HAsciiString)& aDescription,
- const Handle(StepBasic_MeasureWithUnit)& aMagnitude,
+ const Handle(Standard_Transient)& aMagnitude,
const StepDimTol_GeometricToleranceTarget& aTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithModifiers)& aGTWM,
const Handle(StepBasic_LengthMeasureWithUnit)& theMaxTol,
void StepDimTol_GeoTolAndGeoTolWthMod::Init(
const Handle(TCollection_HAsciiString)& theName,
const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(Standard_Transient)& theMagnitude,
const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithModifiers)& theGTWM,
const StepDimTol_GeometricToleranceType theType)
void StepDimTol_GeoTolAndGeoTolWthMod::Init(
const Handle(TCollection_HAsciiString)& theName,
const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(Standard_Transient)& theMagnitude,
const StepDimTol_GeometricToleranceTarget& theTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithModifiers)& theGTWM,
const StepDimTol_GeometricToleranceType theType)
class StepDimTol_GeometricToleranceTarget;
class StepDimTol_GeometricToleranceWithModifiers;
class TCollection_HAsciiString;
-class StepBasic_MeasureWithUnit;
class StepRepr_ShapeAspect;
class StepDimTol_GeoTolAndGeoTolWthMod;
public:
Standard_EXPORT StepDimTol_GeoTolAndGeoTolWthMod();
- Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theName,
- const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
- const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theName,
+ const Handle(TCollection_HAsciiString)& theDescription,
+ const Handle(Standard_Transient)& theMagnitude,
+ const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithModifiers)& theGTWM,
const StepDimTol_GeometricToleranceType theType);
Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& aName,
const Handle(TCollection_HAsciiString)& aDescription,
- const Handle(StepBasic_MeasureWithUnit)& aMagnitude,
+ const Handle(Standard_Transient)& aMagnitude,
const StepDimTol_GeometricToleranceTarget& aTolerancedShapeAspect,
const Handle(StepDimTol_GeometricToleranceWithModifiers)& aGTWM,
const StepDimTol_GeometricToleranceType theType);
void StepDimTol_GeometricTolerance::Init(
const Handle(TCollection_HAsciiString)& theName,
const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(Standard_Transient)& theMagnitude,
const StepDimTol_GeometricToleranceTarget& theTolerancedShapeAspect)
{
//=================================================================================================
void StepDimTol_GeometricTolerance::Init(
- const Handle(TCollection_HAsciiString)& theName,
- const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
- const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect)
+ const Handle(TCollection_HAsciiString)& theName,
+ const Handle(TCollection_HAsciiString)& theDescription,
+ const Handle(Standard_Transient)& theMagnitude,
+ const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect)
{
myName = theName;
//=================================================================================================
-Handle(StepBasic_MeasureWithUnit) StepDimTol_GeometricTolerance::Magnitude() const
+Handle(Standard_Transient) StepDimTol_GeometricTolerance::Magnitude() const
{
return myMagnitude;
}
//=================================================================================================
-void StepDimTol_GeometricTolerance::SetMagnitude(
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude)
+void StepDimTol_GeometricTolerance::SetMagnitude(const Handle(Standard_Transient)& theMagnitude)
{
myMagnitude = theMagnitude;
}
#include <Standard_Transient.hxx>
#include <StepDimTol_GeometricToleranceTarget.hxx>
class TCollection_HAsciiString;
-class StepBasic_MeasureWithUnit;
class StepRepr_ShapeAspect;
class StepDimTol_GeometricTolerance;
Standard_EXPORT StepDimTol_GeometricTolerance();
//! Initialize all fields (own and inherited) AP214
- Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theName,
- const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
- const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect);
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theName,
+ const Handle(TCollection_HAsciiString)& theDescription,
+ const Handle(Standard_Transient)& theMagnitude,
+ const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect);
//! Initialize all fields (own and inherited) AP242
Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theName,
const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(Standard_Transient)& theMagnitude,
const StepDimTol_GeometricToleranceTarget& theTolerancedShapeAspect);
//! Returns field Name
Standard_EXPORT void SetDescription(const Handle(TCollection_HAsciiString)& theDescription);
//! Returns field Magnitude
- Standard_EXPORT Handle(StepBasic_MeasureWithUnit) Magnitude() const;
+ Standard_EXPORT Handle(Standard_Transient) Magnitude() const;
//! Set field Magnitude
- Standard_EXPORT void SetMagnitude(const Handle(StepBasic_MeasureWithUnit)& theMagnitude);
+ Standard_EXPORT void SetMagnitude(const Handle(Standard_Transient)& theMagnitude);
//! Returns field TolerancedShapeAspect
//! Note: in AP214(203) type of this attribute can be only StepRepr_ShapeAspect
private:
Handle(TCollection_HAsciiString) myName;
Handle(TCollection_HAsciiString) myDescription;
- Handle(StepBasic_MeasureWithUnit) myMagnitude;
+ Handle(Standard_Transient) myMagnitude;
StepDimTol_GeometricToleranceTarget myTolerancedShapeAspect;
};
void StepDimTol_GeometricToleranceWithDatumReference::Init(
const Handle(TCollection_HAsciiString)& theGeometricTolerance_Name,
const Handle(TCollection_HAsciiString)& theGeometricTolerance_Description,
- const Handle(StepBasic_MeasureWithUnit)& theGeometricTolerance_Magnitude,
+ const Handle(Standard_Transient)& theGeometricTolerance_Magnitude,
const Handle(StepRepr_ShapeAspect)& theGeometricTolerance_TolerancedShapeAspect,
const Handle(StepDimTol_HArray1OfDatumReference)& theDatumSystem)
{
void StepDimTol_GeometricToleranceWithDatumReference::Init(
const Handle(TCollection_HAsciiString)& theGeometricTolerance_Name,
const Handle(TCollection_HAsciiString)& theGeometricTolerance_Description,
- const Handle(StepBasic_MeasureWithUnit)& theGeometricTolerance_Magnitude,
+ const Handle(Standard_Transient)& theGeometricTolerance_Magnitude,
const StepDimTol_GeometricToleranceTarget& theGeometricTolerance_TolerancedShapeAspect,
const Handle(StepDimTol_HArray1OfDatumSystemOrReference)& theDatumSystem)
{
#include <StepDimTol_HArray1OfDatumSystemOrReference.hxx>
#include <StepDimTol_GeometricTolerance.hxx>
class TCollection_HAsciiString;
-class StepBasic_MeasureWithUnit;
class StepDimTol_GeometricToleranceTarget;
class StepRepr_ShapeAspect;
Standard_EXPORT void Init(
const Handle(TCollection_HAsciiString)& theGeometricTolerance_Name,
const Handle(TCollection_HAsciiString)& theGeometricTolerance_Description,
- const Handle(StepBasic_MeasureWithUnit)& theGeometricTolerance_Magnitude,
+ const Handle(Standard_Transient)& theGeometricTolerance_Magnitude,
const Handle(StepRepr_ShapeAspect)& theGeometricTolerance_TolerancedShapeAspect,
const Handle(StepDimTol_HArray1OfDatumReference)& theDatumSystem);
Standard_EXPORT void Init(
const Handle(TCollection_HAsciiString)& theGeometricTolerance_Name,
const Handle(TCollection_HAsciiString)& theGeometricTolerance_Description,
- const Handle(StepBasic_MeasureWithUnit)& theGeometricTolerance_Magnitude,
+ const Handle(Standard_Transient)& theGeometricTolerance_Magnitude,
const StepDimTol_GeometricToleranceTarget& theGeometricTolerance_TolerancedShapeAspect,
const Handle(StepDimTol_HArray1OfDatumSystemOrReference)& theDatumSystem);
void StepDimTol_GeometricToleranceWithDefinedAreaUnit::Init(
const Handle(TCollection_HAsciiString)& theName,
const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(Standard_Transient)& theMagnitude,
const StepDimTol_GeometricToleranceTarget& theTolerancedShapeAspect,
const Handle(StepBasic_LengthMeasureWithUnit)& theUnitSize,
const StepDimTol_AreaUnitType theUnitType,
//! Initialize all fields (own and inherited)
Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theName,
const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(Standard_Transient)& theMagnitude,
const StepDimTol_GeometricToleranceTarget& theTolerancedShapeAspect,
const Handle(StepBasic_LengthMeasureWithUnit)& theUnitSize,
const StepDimTol_AreaUnitType theAreaType,
void StepDimTol_GeometricToleranceWithDefinedUnit::Init(
const Handle(TCollection_HAsciiString)& theName,
const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(Standard_Transient)& theMagnitude,
const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
const Handle(StepBasic_LengthMeasureWithUnit)& theUnitSize)
{
void StepDimTol_GeometricToleranceWithDefinedUnit::Init(
const Handle(TCollection_HAsciiString)& theName,
const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(Standard_Transient)& theMagnitude,
const StepDimTol_GeometricToleranceTarget& theTolerancedShapeAspect,
const Handle(StepBasic_LengthMeasureWithUnit)& theUnitSize)
{
//! Initialize all fields (own and inherited) AP214
Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theName,
const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(Standard_Transient)& theMagnitude,
const Handle(StepRepr_ShapeAspect)& theTolerancedShapeAspect,
const Handle(StepBasic_LengthMeasureWithUnit)& theUnitSize);
//! Initialize all fields (own and inherited) AP242
Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theName,
const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(Standard_Transient)& theMagnitude,
const StepDimTol_GeometricToleranceTarget& theTolerancedShapeAspect,
const Handle(StepBasic_LengthMeasureWithUnit)& theUnitSize);
void StepDimTol_GeometricToleranceWithMaximumTolerance::Init(
const Handle(TCollection_HAsciiString)& theName,
const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(Standard_Transient)& theMagnitude,
const StepDimTol_GeometricToleranceTarget& theTolerancedShapeAspect,
const Handle(StepDimTol_HArray1OfGeometricToleranceModifier)& theModifiers,
const Handle(StepBasic_LengthMeasureWithUnit)& theMaximumUpperTolerance)
Standard_EXPORT void Init(
const Handle(TCollection_HAsciiString)& theName,
const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(Standard_Transient)& theMagnitude,
const StepDimTol_GeometricToleranceTarget& theTolerancedShapeAspect,
const Handle(StepDimTol_HArray1OfGeometricToleranceModifier)& theModifiers,
const Handle(StepBasic_LengthMeasureWithUnit)& theUnitSize);
void StepDimTol_GeometricToleranceWithModifiers::Init(
const Handle(TCollection_HAsciiString)& theName,
const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(Standard_Transient)& theMagnitude,
const StepDimTol_GeometricToleranceTarget& theTolerancedShapeAspect,
const Handle(StepDimTol_HArray1OfGeometricToleranceModifier)& theModifiers)
{
#include <StepDimTol_HArray1OfGeometricToleranceModifier.hxx>
class TCollection_HAsciiString;
-class StepBasic_MeasureWithUnit;
class StepDimTol_GeometricToleranceTarget;
class StepDimTol_GeometricToleranceWithModifiers;
Standard_EXPORT void Init(
const Handle(TCollection_HAsciiString)& theName,
const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(Standard_Transient)& theMagnitude,
const StepDimTol_GeometricToleranceTarget& theTolerancedShapeAspect,
const Handle(StepDimTol_HArray1OfGeometricToleranceModifier)& theModifiers);
//=================================================================================================
void StepDimTol_ModifiedGeometricTolerance::Init(
- const Handle(TCollection_HAsciiString)& theGeometricTolerance_Name,
- const Handle(TCollection_HAsciiString)& theGeometricTolerance_Description,
- const Handle(StepBasic_MeasureWithUnit)& theGeometricTolerance_Magnitude,
- const Handle(StepRepr_ShapeAspect)& theGeometricTolerance_TolerancedShapeAspect,
- const StepDimTol_LimitCondition theModifier)
+ const Handle(TCollection_HAsciiString)& theGeometricTolerance_Name,
+ const Handle(TCollection_HAsciiString)& theGeometricTolerance_Description,
+ const Handle(Standard_Transient)& theGeometricTolerance_Magnitude,
+ const Handle(StepRepr_ShapeAspect)& theGeometricTolerance_TolerancedShapeAspect,
+ const StepDimTol_LimitCondition theModifier)
{
StepDimTol_GeometricTolerance::Init(theGeometricTolerance_Name,
theGeometricTolerance_Description,
void StepDimTol_ModifiedGeometricTolerance::Init(
const Handle(TCollection_HAsciiString)& theGeometricTolerance_Name,
const Handle(TCollection_HAsciiString)& theGeometricTolerance_Description,
- const Handle(StepBasic_MeasureWithUnit)& theGeometricTolerance_Magnitude,
+ const Handle(Standard_Transient)& theGeometricTolerance_Magnitude,
const StepDimTol_GeometricToleranceTarget& theGeometricTolerance_TolerancedShapeAspect,
const StepDimTol_LimitCondition theModifier)
{
#include <StepDimTol_LimitCondition.hxx>
#include <StepDimTol_GeometricTolerance.hxx>
class TCollection_HAsciiString;
-class StepBasic_MeasureWithUnit;
class StepDimTol_GeometricToleranceTarget;
class StepRepr_ShapeAspect;
//! Initialize all fields (own and inherited) AP214
Standard_EXPORT void Init(
- const Handle(TCollection_HAsciiString)& theGeometricTolerance_Name,
- const Handle(TCollection_HAsciiString)& theGeometricTolerance_Description,
- const Handle(StepBasic_MeasureWithUnit)& theGeometricTolerance_Magnitude,
- const Handle(StepRepr_ShapeAspect)& theGeometricTolerance_TolerancedShapeAspect,
- const StepDimTol_LimitCondition theModifier);
+ const Handle(TCollection_HAsciiString)& theGeometricTolerance_Name,
+ const Handle(TCollection_HAsciiString)& theGeometricTolerance_Description,
+ const Handle(Standard_Transient)& theGeometricTolerance_Magnitude,
+ const Handle(StepRepr_ShapeAspect)& theGeometricTolerance_TolerancedShapeAspect,
+ const StepDimTol_LimitCondition theModifier);
//! Initialize all fields (own and inherited) AP242
Standard_EXPORT void Init(
const Handle(TCollection_HAsciiString)& theGeometricTolerance_Name,
const Handle(TCollection_HAsciiString)& theGeometricTolerance_Description,
- const Handle(StepBasic_MeasureWithUnit)& theGeometricTolerance_Magnitude,
+ const Handle(Standard_Transient)& theGeometricTolerance_Magnitude,
const StepDimTol_GeometricToleranceTarget& theGeometricTolerance_TolerancedShapeAspect,
const StepDimTol_LimitCondition theModifier);
void StepDimTol_UnequallyDisposedGeometricTolerance::Init(
const Handle(TCollection_HAsciiString)& theName,
const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(Standard_Transient)& theMagnitude,
const StepDimTol_GeometricToleranceTarget& theTolerancedShapeAspect,
const Handle(StepBasic_LengthMeasureWithUnit)& theDisplacement)
{
//! Initialize all fields (own and inherited)
Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theName,
const Handle(TCollection_HAsciiString)& theDescription,
- const Handle(StepBasic_MeasureWithUnit)& theMagnitude,
+ const Handle(Standard_Transient)& theMagnitude,
const StepDimTol_GeometricToleranceTarget& theTolerancedShapeAspect,
const Handle(StepBasic_LengthMeasureWithUnit)& theDisplacement);
const Handle(StepBasic_ProductDefinition)&
aProductDefinitionRelationship_RelatingProductDefinition,
const Handle(StepBasic_ProductDefinition)&
- aProductDefinitionRelationship_RelatedProductDefinition,
- const Standard_Integer aRanking,
- const Handle(TCollection_HAsciiString)& aRankingRationale,
- const Handle(StepBasic_MeasureWithUnit)& aQuantity)
+ aProductDefinitionRelationship_RelatedProductDefinition,
+ const Standard_Integer aRanking,
+ const Handle(TCollection_HAsciiString)& aRankingRationale,
+ const Handle(Standard_Transient)& aQuantity)
{
StepRepr_ProductDefinitionUsage::Init(aProductDefinitionRelationship_Id,
aProductDefinitionRelationship_Name,
const StepBasic_ProductDefinitionOrReference&
aProductDefinitionRelationship_RelatingProductDefinition,
const StepBasic_ProductDefinitionOrReference&
- aProductDefinitionRelationship_RelatedProductDefinition,
- const Standard_Integer aRanking,
- const Handle(TCollection_HAsciiString)& aRankingRationale,
- const Handle(StepBasic_MeasureWithUnit)& aQuantity)
+ aProductDefinitionRelationship_RelatedProductDefinition,
+ const Standard_Integer aRanking,
+ const Handle(TCollection_HAsciiString)& aRankingRationale,
+ const Handle(Standard_Transient)& aQuantity)
{
StepRepr_ProductDefinitionUsage::Init(aProductDefinitionRelationship_Id,
aProductDefinitionRelationship_Name,
//=================================================================================================
-Handle(StepBasic_MeasureWithUnit) StepRepr_MakeFromUsageOption::Quantity() const
+Handle(Standard_Transient) StepRepr_MakeFromUsageOption::Quantity() const
{
return theQuantity;
}
//=================================================================================================
-void StepRepr_MakeFromUsageOption::SetQuantity(const Handle(StepBasic_MeasureWithUnit)& aQuantity)
+void StepRepr_MakeFromUsageOption::SetQuantity(const Handle(Standard_Transient)& aQuantity)
{
theQuantity = aQuantity;
}
#include <Standard_Integer.hxx>
#include <StepRepr_ProductDefinitionUsage.hxx>
class TCollection_HAsciiString;
-class StepBasic_MeasureWithUnit;
class StepBasic_ProductDefinition;
class StepRepr_MakeFromUsageOption;
aProductDefinitionRelationship_RelatedProductDefinition,
const Standard_Integer aRanking,
const Handle(TCollection_HAsciiString)& aRankingRationale,
- const Handle(StepBasic_MeasureWithUnit)& aQuantity);
+ const Handle(Standard_Transient)& aQuantity);
//! Initialize all fields (own and inherited)
Standard_EXPORT void Init(
aProductDefinitionRelationship_RelatedProductDefinition,
const Standard_Integer aRanking,
const Handle(TCollection_HAsciiString)& aRankingRationale,
- const Handle(StepBasic_MeasureWithUnit)& aQuantity);
+ const Handle(Standard_Transient)& aQuantity);
//! Returns field Ranking
Standard_EXPORT Standard_Integer Ranking() const;
const Handle(TCollection_HAsciiString)& RankingRationale);
//! Returns field Quantity
- Standard_EXPORT Handle(StepBasic_MeasureWithUnit) Quantity() const;
+ Standard_EXPORT Handle(Standard_Transient) Quantity() const;
//! Set field Quantity
- Standard_EXPORT void SetQuantity(const Handle(StepBasic_MeasureWithUnit)& Quantity);
+ Standard_EXPORT void SetQuantity(const Handle(Standard_Transient)& Quantity);
DEFINE_STANDARD_RTTIEXT(StepRepr_MakeFromUsageOption, StepRepr_ProductDefinitionUsage)
protected:
private:
- Standard_Integer theRanking;
- Handle(TCollection_HAsciiString) theRankingRationale;
- Handle(StepBasic_MeasureWithUnit) theQuantity;
+ Standard_Integer theRanking;
+ Handle(TCollection_HAsciiString) theRankingRationale;
+ Handle(Standard_Transient) theQuantity;
};
#endif // _StepRepr_MakeFromUsageOption_HeaderFile
const Handle(TCollection_HAsciiString)& theShapeAspect_Description,
const Handle(StepRepr_ProductDefinitionShape)& theShapeAspect_OfShape,
const StepData_Logical theShapeAspect_ProductDefinitional,
- const Handle(StepBasic_MeasureWithUnit)& theOffset)
+ const Handle(Standard_Transient)& theOffset)
{
StepRepr_ShapeAspect::Init(theShapeAspect_Name,
theShapeAspect_Description,
#include <StepRepr_DerivedShapeAspect.hxx>
#include <StepData_Logical.hxx>
-class StepBasic_MeasureWithUnit;
class TCollection_HAsciiString;
class StepRepr_ProductDefinitionShape;
const Handle(TCollection_HAsciiString)& theDescription,
const Handle(StepRepr_ProductDefinitionShape)& theOfShape,
const StepData_Logical theProductDefinitional,
- const Handle(StepBasic_MeasureWithUnit)& theOffset);
+ const Handle(Standard_Transient)& theOffset);
//! Returns field Offset
- inline Handle(StepBasic_MeasureWithUnit) Offset() const { return offset; }
+ inline Handle(Standard_Transient) Offset() const { return offset; }
//! Set field Offset
- inline void SetOffset(const Handle(StepBasic_MeasureWithUnit)& theOffset) { offset = theOffset; }
+ inline void SetOffset(const Handle(Standard_Transient)& theOffset) { offset = theOffset; }
DEFINE_STANDARD_RTTIEXT(StepRepr_ParallelOffset, StepRepr_DerivedShapeAspect)
private:
- Handle(StepBasic_MeasureWithUnit) offset;
+ Handle(Standard_Transient) offset;
};
#endif // _StepRepr_ParallelOffset_HeaderFile
const Handle(StepBasic_ProductDefinition)&
aProductDefinitionRelationship_RelatingProductDefinition,
const Handle(StepBasic_ProductDefinition)&
- aProductDefinitionRelationship_RelatedProductDefinition,
- const Standard_Boolean hasAssemblyComponentUsage_ReferenceDesignator,
- const Handle(TCollection_HAsciiString)& aAssemblyComponentUsage_ReferenceDesignator,
- const Handle(StepBasic_MeasureWithUnit)& aQuantity)
+ aProductDefinitionRelationship_RelatedProductDefinition,
+ const Standard_Boolean hasAssemblyComponentUsage_ReferenceDesignator,
+ const Handle(TCollection_HAsciiString)& aAssemblyComponentUsage_ReferenceDesignator,
+ const Handle(Standard_Transient)& aQuantity)
{
StepRepr_AssemblyComponentUsage::Init(aProductDefinitionRelationship_Id,
aProductDefinitionRelationship_Name,
const StepBasic_ProductDefinitionOrReference&
aProductDefinitionRelationship_RelatingProductDefinition,
const StepBasic_ProductDefinitionOrReference&
- aProductDefinitionRelationship_RelatedProductDefinition,
- const Standard_Boolean hasAssemblyComponentUsage_ReferenceDesignator,
- const Handle(TCollection_HAsciiString)& aAssemblyComponentUsage_ReferenceDesignator,
- const Handle(StepBasic_MeasureWithUnit)& aQuantity)
+ aProductDefinitionRelationship_RelatedProductDefinition,
+ const Standard_Boolean hasAssemblyComponentUsage_ReferenceDesignator,
+ const Handle(TCollection_HAsciiString)& aAssemblyComponentUsage_ReferenceDesignator,
+ const Handle(Standard_Transient)& aQuantity)
{
StepRepr_AssemblyComponentUsage::Init(aProductDefinitionRelationship_Id,
aProductDefinitionRelationship_Name,
//=================================================================================================
-Handle(StepBasic_MeasureWithUnit) StepRepr_QuantifiedAssemblyComponentUsage::Quantity() const
+Handle(Standard_Transient) StepRepr_QuantifiedAssemblyComponentUsage::Quantity() const
{
return theQuantity;
}
//=================================================================================================
void StepRepr_QuantifiedAssemblyComponentUsage::SetQuantity(
- const Handle(StepBasic_MeasureWithUnit)& aQuantity)
+ const Handle(Standard_Transient)& aQuantity)
{
theQuantity = aQuantity;
}
#include <Standard_Type.hxx>
#include <StepRepr_AssemblyComponentUsage.hxx>
-class StepBasic_MeasureWithUnit;
class TCollection_HAsciiString;
class StepBasic_ProductDefinition;
aProductDefinitionRelationship_RelatedProductDefinition,
const Standard_Boolean hasAssemblyComponentUsage_ReferenceDesignator,
const Handle(TCollection_HAsciiString)& aAssemblyComponentUsage_ReferenceDesignator,
- const Handle(StepBasic_MeasureWithUnit)& aQuantity);
+ const Handle(Standard_Transient)& aQuantity);
//! Initialize all fields (own and inherited)
Standard_EXPORT void Init(
aProductDefinitionRelationship_RelatedProductDefinition,
const Standard_Boolean hasAssemblyComponentUsage_ReferenceDesignator,
const Handle(TCollection_HAsciiString)& aAssemblyComponentUsage_ReferenceDesignator,
- const Handle(StepBasic_MeasureWithUnit)& aQuantity);
+ const Handle(Standard_Transient)& aQuantity);
//! Returns field Quantity
- Standard_EXPORT Handle(StepBasic_MeasureWithUnit) Quantity() const;
+ Standard_EXPORT Handle(Standard_Transient) Quantity() const;
//! Set field Quantity
- Standard_EXPORT void SetQuantity(const Handle(StepBasic_MeasureWithUnit)& Quantity);
+ Standard_EXPORT void SetQuantity(const Handle(Standard_Transient)& Quantity);
DEFINE_STANDARD_RTTIEXT(StepRepr_QuantifiedAssemblyComponentUsage,
StepRepr_AssemblyComponentUsage)
protected:
private:
- Handle(StepBasic_MeasureWithUnit) theQuantity;
+ Handle(Standard_Transient) theQuantity;
};
#endif // _StepRepr_QuantifiedAssemblyComponentUsage_HeaderFile
void StepShape_MeasureQualification::Init(
const Handle(TCollection_HAsciiString)& name,
const Handle(TCollection_HAsciiString)& description,
- const Handle(StepBasic_MeasureWithUnit)& qualified_measure,
+ const Handle(Standard_Transient)& qualified_measure,
const Handle(StepShape_HArray1OfValueQualifier)& qualifiers)
{
theName = name;
theDescription = description;
}
-Handle(StepBasic_MeasureWithUnit) StepShape_MeasureQualification::QualifiedMeasure() const
+Handle(Standard_Transient) StepShape_MeasureQualification::QualifiedMeasure() const
{
return theQualifiedMeasure;
}
void StepShape_MeasureQualification::SetQualifiedMeasure(
- const Handle(StepBasic_MeasureWithUnit)& qualified_measure)
+ const Handle(Standard_Transient)& qualified_measure)
{
theQualifiedMeasure = qualified_measure;
}
#include <Standard_Transient.hxx>
#include <Standard_Integer.hxx>
class TCollection_HAsciiString;
-class StepBasic_MeasureWithUnit;
class StepShape_ValueQualifier;
class StepShape_MeasureQualification;
Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& name,
const Handle(TCollection_HAsciiString)& description,
- const Handle(StepBasic_MeasureWithUnit)& qualified_measure,
+ const Handle(Standard_Transient)& qualified_measure,
const Handle(StepShape_HArray1OfValueQualifier)& qualifiers);
Standard_EXPORT Handle(TCollection_HAsciiString) Name() const;
Standard_EXPORT void SetDescription(const Handle(TCollection_HAsciiString)& description);
- Standard_EXPORT Handle(StepBasic_MeasureWithUnit) QualifiedMeasure() const;
+ Standard_EXPORT Handle(Standard_Transient) QualifiedMeasure() const;
- Standard_EXPORT void SetQualifiedMeasure(
- const Handle(StepBasic_MeasureWithUnit)& qualified_measure);
+ Standard_EXPORT void SetQualifiedMeasure(const Handle(Standard_Transient)& qualified_measure);
Standard_EXPORT Handle(StepShape_HArray1OfValueQualifier) Qualifiers() const;
private:
Handle(TCollection_HAsciiString) theName;
Handle(TCollection_HAsciiString) theDescription;
- Handle(StepBasic_MeasureWithUnit) theQualifiedMeasure;
+ Handle(Standard_Transient) theQualifiedMeasure;
Handle(StepShape_HArray1OfValueQualifier) theQualifiers;
};
#include <StepBasic_SiUnitAndPlaneAngleUnit.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepRepr_GlobalUnitAssignedContext.hxx>
+#include <StepRepr_ReprItemAndMeasureWithUnit.hxx>
#include <STEPConstruct_UnitContext.hxx>
//=============================================================================
{
Handle(StepBasic_ConversionBasedUnitAndPlaneAngleUnit) aConverUnit =
Handle(StepBasic_ConversionBasedUnitAndPlaneAngleUnit)::DownCast(aPau);
- anAngle = anAngle * aConverUnit->ConversionFactor()->ValueComponent();
- aPau = aConverUnit->ConversionFactor()->UnitComponent().NamedUnit();
+ Handle(StepBasic_MeasureWithUnit) aConversionFactor;
+ Handle(Standard_Transient) aTransientFactor = aConverUnit->ConversionFactor();
+ if (aTransientFactor->IsKind(STANDARD_TYPE(StepBasic_MeasureWithUnit)))
+ {
+ aConversionFactor = Handle(StepBasic_MeasureWithUnit)::DownCast(aTransientFactor);
+ }
+ else if (aTransientFactor->IsKind(STANDARD_TYPE(StepRepr_ReprItemAndMeasureWithUnit)))
+ {
+ Handle(StepRepr_ReprItemAndMeasureWithUnit) aReprMeasureItem =
+ Handle(StepRepr_ReprItemAndMeasureWithUnit)::DownCast(aTransientFactor);
+ aConversionFactor = aReprMeasureItem->GetMeasureWithUnit();
+ }
+ anAngle = anAngle * aConversionFactor->ValueComponent();
+ aPau = aConversionFactor->UnitComponent().NamedUnit();
}
if (aPau.IsNull())
{
--- /dev/null
+puts "===================================="
+puts "For some STEP files we fail for geometric tolerances to read the geometric_tolerance.magnitude"
+puts "===================================="
+pload OCAF
+
+Close D -silent
+
+ReadStep D [locate_data_file bug_gh384.stp]
+
+proc checkEqual {theActualValue theExpectedValue {theTolerance 1.0e-7}} {
+ # Calculate absolute difference
+ set aDifference [expr abs($theActualValue - $theExpectedValue)]
+
+ # Check if difference is within tolerance
+ set isEqual [expr {$aDifference <= $theTolerance}]
+
+ if {!$isEqual} {
+ puts "Error: Tolerance data is not correct"
+ puts "Expected: $theExpectedValue, actual: $anActualValue"
+ }
+}
+
+set aTolerance0 [XGetToleranceValue D "0:1:4:1"]
+checkEqual $aTolerance0 0.75
+
+set aTolerance1 [XGetToleranceValue D "0:1:4:5"]
+checkEqual $aTolerance1 0.75
+
+set aTolerance2 [XGetToleranceValue D "0:1:4:11"]
+checkEqual $aTolerance2 1.25
+
+set aTolerance3 [XGetToleranceValue D "0:1:4:15"]
+checkEqual $aTolerance3 0.5
+
projects / occt.git / commitdiff