v4games
/
assimp
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
assimp/code/Importer/IFC/IFCReaderGen_4.h

5453 lines
244 KiB
C
Raw Normal View History

IFC: introduce new namespace fpr IFC-schema2x3
2018-01-13 09:27:45 +00:00
/*
Open Asset Import Library (ASSIMP)
----------------------------------------------------------------------
Copyright (c) 2006-2010, ASSIMP Development Team
All rights reserved.
Redistribution and use of this software in source and binary forms,
with or without modification, are permitted provided that the
following conditions are met:
* Redistributions of source code must retain the above
copyright notice, this list of conditions and the
following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other
materials provided with the distribution.
* Neither the name of the ASSIMP team, nor the names of its
contributors may be used to endorse or promote products
derived from this software without specific prior
written permission of the ASSIMP Development Team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------
*/
/** MACHINE-GENERATED by scripts/ICFImporter/CppGenerator.py */
#ifndef INCLUDED_IFC_READER_GEN_H
#define INCLUDED_IFC_READER_GEN_H
#include "STEPFile.h"
namespace Assimp {
namespace IFC {
closes https://github.com/assimp/assimp/issues/1752: move guard over include statement.
2018-02-03 07:46:03 +00:00
namespace Schema_4 {
IFC: introduce new namespace fpr IFC-schema2x3
2018-01-13 09:27:45 +00:00
using namespace STEP;
using namespace STEP::EXPRESS;
struct NotImplemented : public ObjectHelper<NotImplemented,0> {
};
// ******************************************************************************
// IFC Custom data types
// ******************************************************************************
// C++ wrapper type for IfcStrippedOptional
typedef BOOLEAN IfcStrippedOptional;
// C++ wrapper type for IfcAbsorbedDoseMeasure
typedef REAL IfcAbsorbedDoseMeasure;
// C++ wrapper type for IfcAccelerationMeasure
typedef REAL IfcAccelerationMeasure;
// C++ wrapper type for IfcAmountOfSubstanceMeasure
typedef REAL IfcAmountOfSubstanceMeasure;
// C++ wrapper type for IfcAngularVelocityMeasure
typedef REAL IfcAngularVelocityMeasure;
// C++ wrapper type for IfcArcIndex
typedef ListOf< INTEGER, 3, 3 > IfcArcIndex;
// C++ wrapper type for IfcAreaDensityMeasure
typedef REAL IfcAreaDensityMeasure;
// C++ wrapper type for IfcAreaMeasure
typedef REAL IfcAreaMeasure;
// C++ wrapper type for IfcBoolean
typedef BOOLEAN IfcBoolean;
// C++ wrapper type for IfcBoxAlignment
typedef STRING IfcBoxAlignment;
// C++ wrapper type for IfcCardinalPointReference
typedef INTEGER IfcCardinalPointReference;
// C++ wrapper type for IfcCompoundPlaneAngleMeasure
typedef ListOf< INTEGER, 3, 4 > IfcCompoundPlaneAngleMeasure;
// C++ wrapper type for IfcContextDependentMeasure
typedef REAL IfcContextDependentMeasure;
// C++ wrapper type for IfcCountMeasure
typedef NUMBER IfcCountMeasure;
// C++ wrapper type for IfcCurvatureMeasure
typedef REAL IfcCurvatureMeasure;
// C++ wrapper type for IfcDate
typedef STRING IfcDate;
// C++ wrapper type for IfcDateTime
typedef STRING IfcDateTime;
// C++ wrapper type for IfcDayInMonthNumber
typedef INTEGER IfcDayInMonthNumber;
// C++ wrapper type for IfcDayInWeekNumber
typedef INTEGER IfcDayInWeekNumber;
// C++ wrapper type for IfcDescriptiveMeasure
typedef STRING IfcDescriptiveMeasure;
// C++ wrapper type for IfcDimensionCount
typedef INTEGER IfcDimensionCount;
// C++ wrapper type for IfcDoseEquivalentMeasure
typedef REAL IfcDoseEquivalentMeasure;
// C++ wrapper type for IfcDuration
typedef STRING IfcDuration;
// C++ wrapper type for IfcDynamicViscosityMeasure
typedef REAL IfcDynamicViscosityMeasure;
// C++ wrapper type for IfcElectricCapacitanceMeasure
typedef REAL IfcElectricCapacitanceMeasure;
// C++ wrapper type for IfcElectricChargeMeasure
typedef REAL IfcElectricChargeMeasure;
// C++ wrapper type for IfcElectricConductanceMeasure
typedef REAL IfcElectricConductanceMeasure;
// C++ wrapper type for IfcElectricCurrentMeasure
typedef REAL IfcElectricCurrentMeasure;
// C++ wrapper type for IfcElectricResistanceMeasure
typedef REAL IfcElectricResistanceMeasure;
// C++ wrapper type for IfcElectricVoltageMeasure
typedef REAL IfcElectricVoltageMeasure;
// C++ wrapper type for IfcEnergyMeasure
typedef REAL IfcEnergyMeasure;
// C++ wrapper type for IfcFontStyle
typedef STRING IfcFontStyle;
// C++ wrapper type for IfcFontVariant
typedef STRING IfcFontVariant;
// C++ wrapper type for IfcFontWeight
typedef STRING IfcFontWeight;
// C++ wrapper type for IfcForceMeasure
typedef REAL IfcForceMeasure;
// C++ wrapper type for IfcFrequencyMeasure
typedef REAL IfcFrequencyMeasure;
// C++ wrapper type for IfcGloballyUniqueId
typedef STRING IfcGloballyUniqueId;
// C++ wrapper type for IfcHeatFluxDensityMeasure
typedef REAL IfcHeatFluxDensityMeasure;
// C++ wrapper type for IfcHeatingValueMeasure
typedef REAL IfcHeatingValueMeasure;
// C++ wrapper type for IfcIdentifier
typedef STRING IfcIdentifier;
// C++ wrapper type for IfcIlluminanceMeasure
typedef REAL IfcIlluminanceMeasure;
// C++ wrapper type for IfcInductanceMeasure
typedef REAL IfcInductanceMeasure;
// C++ wrapper type for IfcInteger
typedef INTEGER IfcInteger;
// C++ wrapper type for IfcIntegerCountRateMeasure
typedef INTEGER IfcIntegerCountRateMeasure;
// C++ wrapper type for IfcIonConcentrationMeasure
typedef REAL IfcIonConcentrationMeasure;
// C++ wrapper type for IfcIsothermalMoistureCapacityMeasure
typedef REAL IfcIsothermalMoistureCapacityMeasure;
// C++ wrapper type for IfcKinematicViscosityMeasure
typedef REAL IfcKinematicViscosityMeasure;
// C++ wrapper type for IfcLabel
typedef STRING IfcLabel;
// C++ wrapper type for IfcLanguageId
typedef STRING IfcLanguageId;
// C++ wrapper type for IfcLengthMeasure
typedef REAL IfcLengthMeasure;
// C++ wrapper type for IfcLineIndex
typedef ListOf< INTEGER, 2, 0 > IfcLineIndex;
// C++ wrapper type for IfcLinearForceMeasure
typedef REAL IfcLinearForceMeasure;
// C++ wrapper type for IfcLinearMomentMeasure
typedef REAL IfcLinearMomentMeasure;
// C++ wrapper type for IfcLinearStiffnessMeasure
typedef REAL IfcLinearStiffnessMeasure;
// C++ wrapper type for IfcLinearVelocityMeasure
typedef REAL IfcLinearVelocityMeasure;
// C++ wrapper type for IfcLogical
typedef LOGICAL IfcLogical;
// C++ wrapper type for IfcLuminousFluxMeasure
typedef REAL IfcLuminousFluxMeasure;
// C++ wrapper type for IfcLuminousIntensityDistributionMeasure
typedef REAL IfcLuminousIntensityDistributionMeasure;
// C++ wrapper type for IfcLuminousIntensityMeasure
typedef REAL IfcLuminousIntensityMeasure;
// C++ wrapper type for IfcMagneticFluxDensityMeasure
typedef REAL IfcMagneticFluxDensityMeasure;
// C++ wrapper type for IfcMagneticFluxMeasure
typedef REAL IfcMagneticFluxMeasure;
// C++ wrapper type for IfcMassDensityMeasure
typedef REAL IfcMassDensityMeasure;
// C++ wrapper type for IfcMassFlowRateMeasure
typedef REAL IfcMassFlowRateMeasure;
// C++ wrapper type for IfcMassMeasure
typedef REAL IfcMassMeasure;
// C++ wrapper type for IfcMassPerLengthMeasure
typedef REAL IfcMassPerLengthMeasure;
// C++ wrapper type for IfcModulusOfElasticityMeasure
typedef REAL IfcModulusOfElasticityMeasure;
// C++ wrapper type for IfcModulusOfLinearSubgradeReactionMeasure
typedef REAL IfcModulusOfLinearSubgradeReactionMeasure;
// C++ wrapper type for IfcModulusOfRotationalSubgradeReactionMeasure
typedef REAL IfcModulusOfRotationalSubgradeReactionMeasure;
// C++ wrapper type for IfcModulusOfSubgradeReactionMeasure
typedef REAL IfcModulusOfSubgradeReactionMeasure;
// C++ wrapper type for IfcMoistureDiffusivityMeasure
typedef REAL IfcMoistureDiffusivityMeasure;
// C++ wrapper type for IfcMolecularWeightMeasure
typedef REAL IfcMolecularWeightMeasure;
// C++ wrapper type for IfcMomentOfInertiaMeasure
typedef REAL IfcMomentOfInertiaMeasure;
// C++ wrapper type for IfcMonetaryMeasure
typedef REAL IfcMonetaryMeasure;
// C++ wrapper type for IfcMonthInYearNumber
typedef INTEGER IfcMonthInYearNumber;
// C++ wrapper type for IfcNonNegativeLengthMeasure
typedef REAL IfcNonNegativeLengthMeasure;
// C++ wrapper type for IfcNormalisedRatioMeasure
typedef REAL IfcNormalisedRatioMeasure;
// C++ wrapper type for IfcNumericMeasure
typedef NUMBER IfcNumericMeasure;
// C++ wrapper type for IfcPHMeasure
typedef REAL IfcPHMeasure;
// C++ wrapper type for IfcParameterValue
typedef REAL IfcParameterValue;
// C++ wrapper type for IfcPlanarForceMeasure
typedef REAL IfcPlanarForceMeasure;
// C++ wrapper type for IfcPlaneAngleMeasure
typedef REAL IfcPlaneAngleMeasure;
// C++ wrapper type for IfcPositiveInteger
typedef INTEGER IfcPositiveInteger;
// C++ wrapper type for IfcPositiveLengthMeasure
typedef REAL IfcPositiveLengthMeasure;
// C++ wrapper type for IfcPositivePlaneAngleMeasure
typedef REAL IfcPositivePlaneAngleMeasure;
// C++ wrapper type for IfcPositiveRatioMeasure
typedef REAL IfcPositiveRatioMeasure;
// C++ wrapper type for IfcPowerMeasure
typedef REAL IfcPowerMeasure;
// C++ wrapper type for IfcPresentableText
typedef STRING IfcPresentableText;
// C++ wrapper type for IfcPressureMeasure
typedef REAL IfcPressureMeasure;
// C++ wrapper type for IfcRadioActivityMeasure
typedef REAL IfcRadioActivityMeasure;
// C++ wrapper type for IfcRatioMeasure
typedef REAL IfcRatioMeasure;
// C++ wrapper type for IfcReal
typedef REAL IfcReal;
// C++ wrapper type for IfcRotationalFrequencyMeasure
typedef REAL IfcRotationalFrequencyMeasure;
// C++ wrapper type for IfcRotationalMassMeasure
typedef REAL IfcRotationalMassMeasure;
// C++ wrapper type for IfcRotationalStiffnessMeasure
typedef REAL IfcRotationalStiffnessMeasure;
// C++ wrapper type for IfcSectionModulusMeasure
typedef REAL IfcSectionModulusMeasure;
// C++ wrapper type for IfcSectionalAreaIntegralMeasure
typedef REAL IfcSectionalAreaIntegralMeasure;
// C++ wrapper type for IfcShearModulusMeasure
typedef REAL IfcShearModulusMeasure;
// C++ wrapper type for IfcSolidAngleMeasure
typedef REAL IfcSolidAngleMeasure;
// C++ wrapper type for IfcSoundPowerLevelMeasure
typedef REAL IfcSoundPowerLevelMeasure;
// C++ wrapper type for IfcSoundPowerMeasure
typedef REAL IfcSoundPowerMeasure;
// C++ wrapper type for IfcSoundPressureLevelMeasure
typedef REAL IfcSoundPressureLevelMeasure;
// C++ wrapper type for IfcSoundPressureMeasure
typedef REAL IfcSoundPressureMeasure;
// C++ wrapper type for IfcSpecificHeatCapacityMeasure
typedef REAL IfcSpecificHeatCapacityMeasure;
// C++ wrapper type for IfcSpecularExponent
typedef REAL IfcSpecularExponent;
// C++ wrapper type for IfcSpecularRoughness
typedef REAL IfcSpecularRoughness;
// C++ wrapper type for IfcTemperatureGradientMeasure
typedef REAL IfcTemperatureGradientMeasure;
// C++ wrapper type for IfcTemperatureRateOfChangeMeasure
typedef REAL IfcTemperatureRateOfChangeMeasure;
// C++ wrapper type for IfcText
typedef STRING IfcText;
// C++ wrapper type for IfcTextAlignment
typedef STRING IfcTextAlignment;
// C++ wrapper type for IfcTextDecoration
typedef STRING IfcTextDecoration;
// C++ wrapper type for IfcTextFontName
typedef STRING IfcTextFontName;
// C++ wrapper type for IfcTextTransformation
typedef STRING IfcTextTransformation;
// C++ wrapper type for IfcThermalAdmittanceMeasure
typedef REAL IfcThermalAdmittanceMeasure;
// C++ wrapper type for IfcThermalConductivityMeasure
typedef REAL IfcThermalConductivityMeasure;
// C++ wrapper type for IfcThermalExpansionCoefficientMeasure
typedef REAL IfcThermalExpansionCoefficientMeasure;
// C++ wrapper type for IfcThermalResistanceMeasure
typedef REAL IfcThermalResistanceMeasure;
// C++ wrapper type for IfcThermalTransmittanceMeasure
typedef REAL IfcThermalTransmittanceMeasure;
// C++ wrapper type for IfcThermodynamicTemperatureMeasure
typedef REAL IfcThermodynamicTemperatureMeasure;
// C++ wrapper type for IfcTime
typedef STRING IfcTime;
// C++ wrapper type for IfcTimeMeasure
typedef REAL IfcTimeMeasure;
// C++ wrapper type for IfcTimeStamp
typedef INTEGER IfcTimeStamp;
// C++ wrapper type for IfcTorqueMeasure
typedef REAL IfcTorqueMeasure;
// C++ wrapper type for IfcURIReference
typedef STRING IfcURIReference;
// C++ wrapper type for IfcVaporPermeabilityMeasure
typedef REAL IfcVaporPermeabilityMeasure;
// C++ wrapper type for IfcVolumeMeasure
typedef REAL IfcVolumeMeasure;
// C++ wrapper type for IfcVolumetricFlowRateMeasure
typedef REAL IfcVolumetricFlowRateMeasure;
// C++ wrapper type for IfcWarpingConstantMeasure
typedef REAL IfcWarpingConstantMeasure;
// C++ wrapper type for IfcWarpingMomentMeasure
typedef REAL IfcWarpingMomentMeasure;
// C++ wrapper type for IfcActionRequestTypeEnum
typedef ENUMERATION IfcActionRequestTypeEnum;
// C++ wrapper type for IfcActionSourceTypeEnum
typedef ENUMERATION IfcActionSourceTypeEnum;
// C++ wrapper type for IfcActionTypeEnum
typedef ENUMERATION IfcActionTypeEnum;
// C++ wrapper type for IfcActuatorTypeEnum
typedef ENUMERATION IfcActuatorTypeEnum;
// C++ wrapper type for IfcAddressTypeEnum
typedef ENUMERATION IfcAddressTypeEnum;
// C++ wrapper type for IfcAirTerminalBoxTypeEnum
typedef ENUMERATION IfcAirTerminalBoxTypeEnum;
// C++ wrapper type for IfcAirTerminalTypeEnum
typedef ENUMERATION IfcAirTerminalTypeEnum;
// C++ wrapper type for IfcAirToAirHeatRecoveryTypeEnum
typedef ENUMERATION IfcAirToAirHeatRecoveryTypeEnum;
// C++ wrapper type for IfcAlarmTypeEnum
typedef ENUMERATION IfcAlarmTypeEnum;
// C++ wrapper type for IfcAnalysisModelTypeEnum
typedef ENUMERATION IfcAnalysisModelTypeEnum;
// C++ wrapper type for IfcAnalysisTheoryTypeEnum
typedef ENUMERATION IfcAnalysisTheoryTypeEnum;
// C++ wrapper type for IfcArithmeticOperatorEnum
typedef ENUMERATION IfcArithmeticOperatorEnum;
// C++ wrapper type for IfcAssemblyPlaceEnum
typedef ENUMERATION IfcAssemblyPlaceEnum;
// C++ wrapper type for IfcAudioVisualApplianceTypeEnum
typedef ENUMERATION IfcAudioVisualApplianceTypeEnum;
// C++ wrapper type for IfcBSplineCurveForm
typedef ENUMERATION IfcBSplineCurveForm;
// C++ wrapper type for IfcBSplineSurfaceForm
typedef ENUMERATION IfcBSplineSurfaceForm;
// C++ wrapper type for IfcBeamTypeEnum
typedef ENUMERATION IfcBeamTypeEnum;
// C++ wrapper type for IfcBenchmarkEnum
typedef ENUMERATION IfcBenchmarkEnum;
// C++ wrapper type for IfcBoilerTypeEnum
typedef ENUMERATION IfcBoilerTypeEnum;
// C++ wrapper type for IfcBooleanOperator
typedef ENUMERATION IfcBooleanOperator;
// C++ wrapper type for IfcBuildingElementPartTypeEnum
typedef ENUMERATION IfcBuildingElementPartTypeEnum;
// C++ wrapper type for IfcBuildingElementProxyTypeEnum
typedef ENUMERATION IfcBuildingElementProxyTypeEnum;
// C++ wrapper type for IfcBuildingSystemTypeEnum
typedef ENUMERATION IfcBuildingSystemTypeEnum;
// C++ wrapper type for IfcBurnerTypeEnum
typedef ENUMERATION IfcBurnerTypeEnum;
// C++ wrapper type for IfcCableCarrierFittingTypeEnum
typedef ENUMERATION IfcCableCarrierFittingTypeEnum;
// C++ wrapper type for IfcCableCarrierSegmentTypeEnum
typedef ENUMERATION IfcCableCarrierSegmentTypeEnum;
// C++ wrapper type for IfcCableFittingTypeEnum
typedef ENUMERATION IfcCableFittingTypeEnum;
// C++ wrapper type for IfcCableSegmentTypeEnum
typedef ENUMERATION IfcCableSegmentTypeEnum;
// C++ wrapper type for IfcChangeActionEnum
typedef ENUMERATION IfcChangeActionEnum;
// C++ wrapper type for IfcChillerTypeEnum
typedef ENUMERATION IfcChillerTypeEnum;
// C++ wrapper type for IfcChimneyTypeEnum
typedef ENUMERATION IfcChimneyTypeEnum;
// C++ wrapper type for IfcCoilTypeEnum
typedef ENUMERATION IfcCoilTypeEnum;
// C++ wrapper type for IfcColumnTypeEnum
typedef ENUMERATION IfcColumnTypeEnum;
// C++ wrapper type for IfcCommunicationsApplianceTypeEnum
typedef ENUMERATION IfcCommunicationsApplianceTypeEnum;
// C++ wrapper type for IfcComplexPropertyTemplateTypeEnum
typedef ENUMERATION IfcComplexPropertyTemplateTypeEnum;
// C++ wrapper type for IfcCompressorTypeEnum
typedef ENUMERATION IfcCompressorTypeEnum;
// C++ wrapper type for IfcCondenserTypeEnum
typedef ENUMERATION IfcCondenserTypeEnum;
// C++ wrapper type for IfcConnectionTypeEnum
typedef ENUMERATION IfcConnectionTypeEnum;
// C++ wrapper type for IfcConstraintEnum
typedef ENUMERATION IfcConstraintEnum;
// C++ wrapper type for IfcConstructionEquipmentResourceTypeEnum
typedef ENUMERATION IfcConstructionEquipmentResourceTypeEnum;
// C++ wrapper type for IfcConstructionMaterialResourceTypeEnum
typedef ENUMERATION IfcConstructionMaterialResourceTypeEnum;
// C++ wrapper type for IfcConstructionProductResourceTypeEnum
typedef ENUMERATION IfcConstructionProductResourceTypeEnum;
// C++ wrapper type for IfcControllerTypeEnum
typedef ENUMERATION IfcControllerTypeEnum;
// C++ wrapper type for IfcCooledBeamTypeEnum
typedef ENUMERATION IfcCooledBeamTypeEnum;
// C++ wrapper type for IfcCoolingTowerTypeEnum
typedef ENUMERATION IfcCoolingTowerTypeEnum;
// C++ wrapper type for IfcCostItemTypeEnum
typedef ENUMERATION IfcCostItemTypeEnum;
// C++ wrapper type for IfcCostScheduleTypeEnum
typedef ENUMERATION IfcCostScheduleTypeEnum;
// C++ wrapper type for IfcCoveringTypeEnum
typedef ENUMERATION IfcCoveringTypeEnum;
// C++ wrapper type for IfcCrewResourceTypeEnum
typedef ENUMERATION IfcCrewResourceTypeEnum;
// C++ wrapper type for IfcCurtainWallTypeEnum
typedef ENUMERATION IfcCurtainWallTypeEnum;
// C++ wrapper type for IfcCurveInterpolationEnum
typedef ENUMERATION IfcCurveInterpolationEnum;
// C++ wrapper type for IfcDamperTypeEnum
typedef ENUMERATION IfcDamperTypeEnum;
// C++ wrapper type for IfcDataOriginEnum
typedef ENUMERATION IfcDataOriginEnum;
// C++ wrapper type for IfcDerivedUnitEnum
typedef ENUMERATION IfcDerivedUnitEnum;
// C++ wrapper type for IfcDirectionSenseEnum
typedef ENUMERATION IfcDirectionSenseEnum;
// C++ wrapper type for IfcDiscreteAccessoryTypeEnum
typedef ENUMERATION IfcDiscreteAccessoryTypeEnum;
// C++ wrapper type for IfcDistributionChamberElementTypeEnum
typedef ENUMERATION IfcDistributionChamberElementTypeEnum;
// C++ wrapper type for IfcDistributionPortTypeEnum
typedef ENUMERATION IfcDistributionPortTypeEnum;
// C++ wrapper type for IfcDistributionSystemEnum
typedef ENUMERATION IfcDistributionSystemEnum;
// C++ wrapper type for IfcDocumentConfidentialityEnum
typedef ENUMERATION IfcDocumentConfidentialityEnum;
// C++ wrapper type for IfcDocumentStatusEnum
typedef ENUMERATION IfcDocumentStatusEnum;
// C++ wrapper type for IfcDoorPanelOperationEnum
typedef ENUMERATION IfcDoorPanelOperationEnum;
// C++ wrapper type for IfcDoorPanelPositionEnum
typedef ENUMERATION IfcDoorPanelPositionEnum;
// C++ wrapper type for IfcDoorStyleConstructionEnum
typedef ENUMERATION IfcDoorStyleConstructionEnum;
// C++ wrapper type for IfcDoorStyleOperationEnum
typedef ENUMERATION IfcDoorStyleOperationEnum;
// C++ wrapper type for IfcDoorTypeEnum
typedef ENUMERATION IfcDoorTypeEnum;
// C++ wrapper type for IfcDoorTypeOperationEnum
typedef ENUMERATION IfcDoorTypeOperationEnum;
// C++ wrapper type for IfcDuctFittingTypeEnum
typedef ENUMERATION IfcDuctFittingTypeEnum;
// C++ wrapper type for IfcDuctSegmentTypeEnum
typedef ENUMERATION IfcDuctSegmentTypeEnum;
// C++ wrapper type for IfcDuctSilencerTypeEnum
typedef ENUMERATION IfcDuctSilencerTypeEnum;
// C++ wrapper type for IfcElectricApplianceTypeEnum
typedef ENUMERATION IfcElectricApplianceTypeEnum;
// C++ wrapper type for IfcElectricDistributionBoardTypeEnum
typedef ENUMERATION IfcElectricDistributionBoardTypeEnum;
// C++ wrapper type for IfcElectricFlowStorageDeviceTypeEnum
typedef ENUMERATION IfcElectricFlowStorageDeviceTypeEnum;
// C++ wrapper type for IfcElectricGeneratorTypeEnum
typedef ENUMERATION IfcElectricGeneratorTypeEnum;
// C++ wrapper type for IfcElectricMotorTypeEnum
typedef ENUMERATION IfcElectricMotorTypeEnum;
// C++ wrapper type for IfcElectricTimeControlTypeEnum
typedef ENUMERATION IfcElectricTimeControlTypeEnum;
// C++ wrapper type for IfcElementAssemblyTypeEnum
typedef ENUMERATION IfcElementAssemblyTypeEnum;
// C++ wrapper type for IfcElementCompositionEnum
typedef ENUMERATION IfcElementCompositionEnum;
// C++ wrapper type for IfcEngineTypeEnum
typedef ENUMERATION IfcEngineTypeEnum;
// C++ wrapper type for IfcEvaporativeCoolerTypeEnum
typedef ENUMERATION IfcEvaporativeCoolerTypeEnum;
// C++ wrapper type for IfcEvaporatorTypeEnum
typedef ENUMERATION IfcEvaporatorTypeEnum;
// C++ wrapper type for IfcEventTriggerTypeEnum
typedef ENUMERATION IfcEventTriggerTypeEnum;
// C++ wrapper type for IfcEventTypeEnum
typedef ENUMERATION IfcEventTypeEnum;
// C++ wrapper type for IfcExternalSpatialElementTypeEnum
typedef ENUMERATION IfcExternalSpatialElementTypeEnum;
// C++ wrapper type for IfcFanTypeEnum
typedef ENUMERATION IfcFanTypeEnum;
// C++ wrapper type for IfcFastenerTypeEnum
typedef ENUMERATION IfcFastenerTypeEnum;
// C++ wrapper type for IfcFilterTypeEnum
typedef ENUMERATION IfcFilterTypeEnum;
// C++ wrapper type for IfcFireSuppressionTerminalTypeEnum
typedef ENUMERATION IfcFireSuppressionTerminalTypeEnum;
// C++ wrapper type for IfcFlowDirectionEnum
typedef ENUMERATION IfcFlowDirectionEnum;
// C++ wrapper type for IfcFlowInstrumentTypeEnum
typedef ENUMERATION IfcFlowInstrumentTypeEnum;
// C++ wrapper type for IfcFlowMeterTypeEnum
typedef ENUMERATION IfcFlowMeterTypeEnum;
// C++ wrapper type for IfcFootingTypeEnum
typedef ENUMERATION IfcFootingTypeEnum;
// C++ wrapper type for IfcFurnitureTypeEnum
typedef ENUMERATION IfcFurnitureTypeEnum;
// C++ wrapper type for IfcGeographicElementTypeEnum
typedef ENUMERATION IfcGeographicElementTypeEnum;
// C++ wrapper type for IfcGeometricProjectionEnum
typedef ENUMERATION IfcGeometricProjectionEnum;
// C++ wrapper type for IfcGlobalOrLocalEnum
typedef ENUMERATION IfcGlobalOrLocalEnum;
// C++ wrapper type for IfcGridTypeEnum
typedef ENUMERATION IfcGridTypeEnum;
// C++ wrapper type for IfcHeatExchangerTypeEnum
typedef ENUMERATION IfcHeatExchangerTypeEnum;
// C++ wrapper type for IfcHumidifierTypeEnum
typedef ENUMERATION IfcHumidifierTypeEnum;
// C++ wrapper type for IfcInterceptorTypeEnum
typedef ENUMERATION IfcInterceptorTypeEnum;
// C++ wrapper type for IfcInternalOrExternalEnum
typedef ENUMERATION IfcInternalOrExternalEnum;
// C++ wrapper type for IfcInventoryTypeEnum
typedef ENUMERATION IfcInventoryTypeEnum;
// C++ wrapper type for IfcJunctionBoxTypeEnum
typedef ENUMERATION IfcJunctionBoxTypeEnum;
// C++ wrapper type for IfcKnotType
typedef ENUMERATION IfcKnotType;
// C++ wrapper type for IfcLaborResourceTypeEnum
typedef ENUMERATION IfcLaborResourceTypeEnum;
// C++ wrapper type for IfcLampTypeEnum
typedef ENUMERATION IfcLampTypeEnum;
// C++ wrapper type for IfcLayerSetDirectionEnum
typedef ENUMERATION IfcLayerSetDirectionEnum;
// C++ wrapper type for IfcLightDistributionCurveEnum
typedef ENUMERATION IfcLightDistributionCurveEnum;
// C++ wrapper type for IfcLightEmissionSourceEnum
typedef ENUMERATION IfcLightEmissionSourceEnum;
// C++ wrapper type for IfcLightFixtureTypeEnum
typedef ENUMERATION IfcLightFixtureTypeEnum;
// C++ wrapper type for IfcLoadGroupTypeEnum
typedef ENUMERATION IfcLoadGroupTypeEnum;
// C++ wrapper type for IfcLogicalOperatorEnum
typedef ENUMERATION IfcLogicalOperatorEnum;
// C++ wrapper type for IfcMechanicalFastenerTypeEnum
typedef ENUMERATION IfcMechanicalFastenerTypeEnum;
// C++ wrapper type for IfcMedicalDeviceTypeEnum
typedef ENUMERATION IfcMedicalDeviceTypeEnum;
// C++ wrapper type for IfcMemberTypeEnum
typedef ENUMERATION IfcMemberTypeEnum;
// C++ wrapper type for IfcMotorConnectionTypeEnum
typedef ENUMERATION IfcMotorConnectionTypeEnum;
// C++ wrapper type for IfcNullStyle
typedef ENUMERATION IfcNullStyle;
// C++ wrapper type for IfcObjectTypeEnum
typedef ENUMERATION IfcObjectTypeEnum;
// C++ wrapper type for IfcObjectiveEnum
typedef ENUMERATION IfcObjectiveEnum;
// C++ wrapper type for IfcOccupantTypeEnum
typedef ENUMERATION IfcOccupantTypeEnum;
// C++ wrapper type for IfcOpeningElementTypeEnum
typedef ENUMERATION IfcOpeningElementTypeEnum;
// C++ wrapper type for IfcOutletTypeEnum
typedef ENUMERATION IfcOutletTypeEnum;
// C++ wrapper type for IfcPerformanceHistoryTypeEnum
typedef ENUMERATION IfcPerformanceHistoryTypeEnum;
// C++ wrapper type for IfcPermeableCoveringOperationEnum
typedef ENUMERATION IfcPermeableCoveringOperationEnum;
// C++ wrapper type for IfcPermitTypeEnum
typedef ENUMERATION IfcPermitTypeEnum;
// C++ wrapper type for IfcPhysicalOrVirtualEnum
typedef ENUMERATION IfcPhysicalOrVirtualEnum;
// C++ wrapper type for IfcPileConstructionEnum
typedef ENUMERATION IfcPileConstructionEnum;
// C++ wrapper type for IfcPileTypeEnum
typedef ENUMERATION IfcPileTypeEnum;
// C++ wrapper type for IfcPipeFittingTypeEnum
typedef ENUMERATION IfcPipeFittingTypeEnum;
// C++ wrapper type for IfcPipeSegmentTypeEnum
typedef ENUMERATION IfcPipeSegmentTypeEnum;
// C++ wrapper type for IfcPlateTypeEnum
typedef ENUMERATION IfcPlateTypeEnum;
// C++ wrapper type for IfcPreferredSurfaceCurveRepresentation
typedef ENUMERATION IfcPreferredSurfaceCurveRepresentation;
// C++ wrapper type for IfcProcedureTypeEnum
typedef ENUMERATION IfcProcedureTypeEnum;
// C++ wrapper type for IfcProfileTypeEnum
typedef ENUMERATION IfcProfileTypeEnum;
// C++ wrapper type for IfcProjectOrderTypeEnum
typedef ENUMERATION IfcProjectOrderTypeEnum;
// C++ wrapper type for IfcProjectedOrTrueLengthEnum
typedef ENUMERATION IfcProjectedOrTrueLengthEnum;
// C++ wrapper type for IfcProjectionElementTypeEnum
typedef ENUMERATION IfcProjectionElementTypeEnum;
// C++ wrapper type for IfcPropertySetTemplateTypeEnum
typedef ENUMERATION IfcPropertySetTemplateTypeEnum;
// C++ wrapper type for IfcProtectiveDeviceTrippingUnitTypeEnum
typedef ENUMERATION IfcProtectiveDeviceTrippingUnitTypeEnum;
// C++ wrapper type for IfcProtectiveDeviceTypeEnum
typedef ENUMERATION IfcProtectiveDeviceTypeEnum;
// C++ wrapper type for IfcPumpTypeEnum
typedef ENUMERATION IfcPumpTypeEnum;
// C++ wrapper type for IfcRailingTypeEnum
typedef ENUMERATION IfcRailingTypeEnum;
// C++ wrapper type for IfcRampFlightTypeEnum
typedef ENUMERATION IfcRampFlightTypeEnum;
// C++ wrapper type for IfcRampTypeEnum
typedef ENUMERATION IfcRampTypeEnum;
// C++ wrapper type for IfcRecurrenceTypeEnum
typedef ENUMERATION IfcRecurrenceTypeEnum;
// C++ wrapper type for IfcReflectanceMethodEnum
typedef ENUMERATION IfcReflectanceMethodEnum;
// C++ wrapper type for IfcReinforcingBarRoleEnum
typedef ENUMERATION IfcReinforcingBarRoleEnum;
// C++ wrapper type for IfcReinforcingBarSurfaceEnum
typedef ENUMERATION IfcReinforcingBarSurfaceEnum;
// C++ wrapper type for IfcReinforcingBarTypeEnum
typedef ENUMERATION IfcReinforcingBarTypeEnum;
// C++ wrapper type for IfcReinforcingMeshTypeEnum
typedef ENUMERATION IfcReinforcingMeshTypeEnum;
// C++ wrapper type for IfcRoleEnum
typedef ENUMERATION IfcRoleEnum;
// C++ wrapper type for IfcRoofTypeEnum
typedef ENUMERATION IfcRoofTypeEnum;
// C++ wrapper type for IfcSIPrefix
typedef ENUMERATION IfcSIPrefix;
// C++ wrapper type for IfcSIUnitName
typedef ENUMERATION IfcSIUnitName;
// C++ wrapper type for IfcSanitaryTerminalTypeEnum
typedef ENUMERATION IfcSanitaryTerminalTypeEnum;
// C++ wrapper type for IfcSectionTypeEnum
typedef ENUMERATION IfcSectionTypeEnum;
// C++ wrapper type for IfcSensorTypeEnum
typedef ENUMERATION IfcSensorTypeEnum;
// C++ wrapper type for IfcSequenceEnum
typedef ENUMERATION IfcSequenceEnum;
// C++ wrapper type for IfcShadingDeviceTypeEnum
typedef ENUMERATION IfcShadingDeviceTypeEnum;
// C++ wrapper type for IfcSimplePropertyTemplateTypeEnum
typedef ENUMERATION IfcSimplePropertyTemplateTypeEnum;
// C++ wrapper type for IfcSlabTypeEnum
typedef ENUMERATION IfcSlabTypeEnum;
// C++ wrapper type for IfcSolarDeviceTypeEnum
typedef ENUMERATION IfcSolarDeviceTypeEnum;
// C++ wrapper type for IfcSpaceHeaterTypeEnum
typedef ENUMERATION IfcSpaceHeaterTypeEnum;
// C++ wrapper type for IfcSpaceTypeEnum
typedef ENUMERATION IfcSpaceTypeEnum;
// C++ wrapper type for IfcSpatialZoneTypeEnum
typedef ENUMERATION IfcSpatialZoneTypeEnum;
// C++ wrapper type for IfcStackTerminalTypeEnum
typedef ENUMERATION IfcStackTerminalTypeEnum;
// C++ wrapper type for IfcStairFlightTypeEnum
typedef ENUMERATION IfcStairFlightTypeEnum;
// C++ wrapper type for IfcStairTypeEnum
typedef ENUMERATION IfcStairTypeEnum;
// C++ wrapper type for IfcStateEnum
typedef ENUMERATION IfcStateEnum;
// C++ wrapper type for IfcStructuralCurveActivityTypeEnum
typedef ENUMERATION IfcStructuralCurveActivityTypeEnum;
// C++ wrapper type for IfcStructuralCurveMemberTypeEnum
typedef ENUMERATION IfcStructuralCurveMemberTypeEnum;
// C++ wrapper type for IfcStructuralSurfaceActivityTypeEnum
typedef ENUMERATION IfcStructuralSurfaceActivityTypeEnum;
// C++ wrapper type for IfcStructuralSurfaceMemberTypeEnum
typedef ENUMERATION IfcStructuralSurfaceMemberTypeEnum;
// C++ wrapper type for IfcSubContractResourceTypeEnum
typedef ENUMERATION IfcSubContractResourceTypeEnum;
// C++ wrapper type for IfcSurfaceFeatureTypeEnum
typedef ENUMERATION IfcSurfaceFeatureTypeEnum;
// C++ wrapper type for IfcSurfaceSide
typedef ENUMERATION IfcSurfaceSide;
// C++ wrapper type for IfcSwitchingDeviceTypeEnum
typedef ENUMERATION IfcSwitchingDeviceTypeEnum;
// C++ wrapper type for IfcSystemFurnitureElementTypeEnum
typedef ENUMERATION IfcSystemFurnitureElementTypeEnum;
// C++ wrapper type for IfcTankTypeEnum
typedef ENUMERATION IfcTankTypeEnum;
// C++ wrapper type for IfcTaskDurationEnum
typedef ENUMERATION IfcTaskDurationEnum;
// C++ wrapper type for IfcTaskTypeEnum
typedef ENUMERATION IfcTaskTypeEnum;
// C++ wrapper type for IfcTendonAnchorTypeEnum
typedef ENUMERATION IfcTendonAnchorTypeEnum;
// C++ wrapper type for IfcTendonTypeEnum
typedef ENUMERATION IfcTendonTypeEnum;
// C++ wrapper type for IfcTextPath
typedef ENUMERATION IfcTextPath;
// C++ wrapper type for IfcTimeSeriesDataTypeEnum
typedef ENUMERATION IfcTimeSeriesDataTypeEnum;
// C++ wrapper type for IfcTransformerTypeEnum
typedef ENUMERATION IfcTransformerTypeEnum;
// C++ wrapper type for IfcTransitionCode
typedef ENUMERATION IfcTransitionCode;
// C++ wrapper type for IfcTransportElementTypeEnum
typedef ENUMERATION IfcTransportElementTypeEnum;
// C++ wrapper type for IfcTrimmingPreference
typedef ENUMERATION IfcTrimmingPreference;
// C++ wrapper type for IfcTubeBundleTypeEnum
typedef ENUMERATION IfcTubeBundleTypeEnum;
// C++ wrapper type for IfcUnitEnum
typedef ENUMERATION IfcUnitEnum;
// C++ wrapper type for IfcUnitaryControlElementTypeEnum
typedef ENUMERATION IfcUnitaryControlElementTypeEnum;
// C++ wrapper type for IfcUnitaryEquipmentTypeEnum
typedef ENUMERATION IfcUnitaryEquipmentTypeEnum;
// C++ wrapper type for IfcValveTypeEnum
typedef ENUMERATION IfcValveTypeEnum;
// C++ wrapper type for IfcVibrationIsolatorTypeEnum
typedef ENUMERATION IfcVibrationIsolatorTypeEnum;
// C++ wrapper type for IfcVoidingFeatureTypeEnum
typedef ENUMERATION IfcVoidingFeatureTypeEnum;
// C++ wrapper type for IfcWallTypeEnum
typedef ENUMERATION IfcWallTypeEnum;
// C++ wrapper type for IfcWasteTerminalTypeEnum
typedef ENUMERATION IfcWasteTerminalTypeEnum;
// C++ wrapper type for IfcWindowPanelOperationEnum
typedef ENUMERATION IfcWindowPanelOperationEnum;
// C++ wrapper type for IfcWindowPanelPositionEnum
typedef ENUMERATION IfcWindowPanelPositionEnum;
// C++ wrapper type for IfcWindowStyleConstructionEnum
typedef ENUMERATION IfcWindowStyleConstructionEnum;
// C++ wrapper type for IfcWindowStyleOperationEnum
typedef ENUMERATION IfcWindowStyleOperationEnum;
// C++ wrapper type for IfcWindowTypeEnum
typedef ENUMERATION IfcWindowTypeEnum;
// C++ wrapper type for IfcWindowTypePartitioningEnum
typedef ENUMERATION IfcWindowTypePartitioningEnum;
// C++ wrapper type for IfcWorkCalendarTypeEnum
typedef ENUMERATION IfcWorkCalendarTypeEnum;
// C++ wrapper type for IfcWorkPlanTypeEnum
typedef ENUMERATION IfcWorkPlanTypeEnum;
// C++ wrapper type for IfcWorkScheduleTypeEnum
typedef ENUMERATION IfcWorkScheduleTypeEnum;
// C++ wrapper type for IfcActorSelect
typedef SELECT IfcActorSelect;
// C++ wrapper type for IfcAppliedValueSelect
typedef SELECT IfcAppliedValueSelect;
// C++ wrapper type for IfcAxis2Placement
typedef SELECT IfcAxis2Placement;
// C++ wrapper type for IfcBendingParameterSelect
typedef SELECT IfcBendingParameterSelect;
// C++ wrapper type for IfcBooleanOperand
typedef SELECT IfcBooleanOperand;
// C++ wrapper type for IfcClassificationReferenceSelect
typedef SELECT IfcClassificationReferenceSelect;
// C++ wrapper type for IfcClassificationSelect
typedef SELECT IfcClassificationSelect;
// C++ wrapper type for IfcColour
typedef SELECT IfcColour;
// C++ wrapper type for IfcColourOrFactor
typedef SELECT IfcColourOrFactor;
// C++ wrapper type for IfcCoordinateReferenceSystemSelect
typedef SELECT IfcCoordinateReferenceSystemSelect;
// C++ wrapper type for IfcCsgSelect
typedef SELECT IfcCsgSelect;
// C++ wrapper type for IfcCurveFontOrScaledCurveFontSelect
typedef SELECT IfcCurveFontOrScaledCurveFontSelect;
// C++ wrapper type for IfcCurveOnSurface
typedef SELECT IfcCurveOnSurface;
// C++ wrapper type for IfcCurveOrEdgeCurve
typedef SELECT IfcCurveOrEdgeCurve;
// C++ wrapper type for IfcCurveStyleFontSelect
typedef SELECT IfcCurveStyleFontSelect;
// C++ wrapper type for IfcDefinitionSelect
typedef SELECT IfcDefinitionSelect;
// C++ wrapper type for IfcDerivedMeasureValue
typedef SELECT IfcDerivedMeasureValue;
// C++ wrapper type for IfcDocumentSelect
typedef SELECT IfcDocumentSelect;
// C++ wrapper type for IfcFillStyleSelect
typedef SELECT IfcFillStyleSelect;
// C++ wrapper type for IfcGeometricSetSelect
typedef SELECT IfcGeometricSetSelect;
// C++ wrapper type for IfcGridPlacementDirectionSelect
typedef SELECT IfcGridPlacementDirectionSelect;
// C++ wrapper type for IfcHatchLineDistanceSelect
typedef SELECT IfcHatchLineDistanceSelect;
// C++ wrapper type for IfcLayeredItem
typedef SELECT IfcLayeredItem;
// C++ wrapper type for IfcLibrarySelect
typedef SELECT IfcLibrarySelect;
// C++ wrapper type for IfcLightDistributionDataSourceSelect
typedef SELECT IfcLightDistributionDataSourceSelect;
// C++ wrapper type for IfcMaterialSelect
typedef SELECT IfcMaterialSelect;
// C++ wrapper type for IfcMeasureValue
typedef SELECT IfcMeasureValue;
// C++ wrapper type for IfcMetricValueSelect
typedef SELECT IfcMetricValueSelect;
// C++ wrapper type for IfcModulusOfRotationalSubgradeReactionSelect
typedef SELECT IfcModulusOfRotationalSubgradeReactionSelect;
// C++ wrapper type for IfcModulusOfSubgradeReactionSelect
typedef SELECT IfcModulusOfSubgradeReactionSelect;
// C++ wrapper type for IfcModulusOfTranslationalSubgradeReactionSelect
typedef SELECT IfcModulusOfTranslationalSubgradeReactionSelect;
// C++ wrapper type for IfcObjectReferenceSelect
typedef SELECT IfcObjectReferenceSelect;
// C++ wrapper type for IfcPointOrVertexPoint
typedef SELECT IfcPointOrVertexPoint;
// C++ wrapper type for IfcPresentationStyleSelect
typedef SELECT IfcPresentationStyleSelect;
// C++ wrapper type for IfcProcessSelect
typedef SELECT IfcProcessSelect;
// C++ wrapper type for IfcProductRepresentationSelect
typedef SELECT IfcProductRepresentationSelect;
// C++ wrapper type for IfcProductSelect
typedef SELECT IfcProductSelect;
// C++ wrapper type for IfcPropertySetDefinitionSelect
typedef SELECT IfcPropertySetDefinitionSelect;
// C++ wrapper type for IfcResourceObjectSelect
typedef SELECT IfcResourceObjectSelect;
// C++ wrapper type for IfcResourceSelect
typedef SELECT IfcResourceSelect;
// C++ wrapper type for IfcRotationalStiffnessSelect
typedef SELECT IfcRotationalStiffnessSelect;
// C++ wrapper type for IfcSegmentIndexSelect
typedef SELECT IfcSegmentIndexSelect;
// C++ wrapper type for IfcShell
typedef SELECT IfcShell;
// C++ wrapper type for IfcSimpleValue
typedef SELECT IfcSimpleValue;
// C++ wrapper type for IfcSizeSelect
typedef SELECT IfcSizeSelect;
// C++ wrapper type for IfcSolidOrShell
typedef SELECT IfcSolidOrShell;
// C++ wrapper type for IfcSpaceBoundarySelect
typedef SELECT IfcSpaceBoundarySelect;
// C++ wrapper type for IfcSpecularHighlightSelect
typedef SELECT IfcSpecularHighlightSelect;
// C++ wrapper type for IfcStructuralActivityAssignmentSelect
typedef SELECT IfcStructuralActivityAssignmentSelect;
// C++ wrapper type for IfcStyleAssignmentSelect
typedef SELECT IfcStyleAssignmentSelect;
// C++ wrapper type for IfcSurfaceOrFaceSurface
typedef SELECT IfcSurfaceOrFaceSurface;
// C++ wrapper type for IfcSurfaceStyleElementSelect
typedef SELECT IfcSurfaceStyleElementSelect;
// C++ wrapper type for IfcTextFontSelect
typedef SELECT IfcTextFontSelect;
// C++ wrapper type for IfcTimeOrRatioSelect
typedef SELECT IfcTimeOrRatioSelect;
// C++ wrapper type for IfcTranslationalStiffnessSelect
typedef SELECT IfcTranslationalStiffnessSelect;
// C++ wrapper type for IfcTrimmingSelect
typedef SELECT IfcTrimmingSelect;
// C++ wrapper type for IfcUnit
typedef SELECT IfcUnit;
// C++ wrapper type for IfcValue
typedef SELECT IfcValue;
// C++ wrapper type for IfcVectorOrDirection
typedef SELECT IfcVectorOrDirection;
// C++ wrapper type for IfcWarpingStiffnessSelect
typedef SELECT IfcWarpingStiffnessSelect;
// ******************************************************************************
// IFC Entities
// ******************************************************************************
struct IfcRoot;
struct IfcObjectDefinition;
struct IfcObject;
struct IfcControl;
struct IfcActionRequest;
struct IfcActor;
typedef NotImplemented IfcActorRole; // (not currently used by Assimp)
struct IfcProduct;
struct IfcElement;
struct IfcDistributionElement;
struct IfcDistributionControlElement;
struct IfcActuator;
struct IfcTypeObject;
struct IfcTypeProduct;
struct IfcElementType;
struct IfcDistributionElementType;
struct IfcDistributionControlElementType;
struct IfcActuatorType;
typedef NotImplemented IfcAddress; // (not currently used by Assimp)
struct IfcRepresentationItem;
struct IfcGeometricRepresentationItem;
struct IfcSolidModel;
struct IfcManifoldSolidBrep;
struct IfcAdvancedBrep;
struct IfcAdvancedBrepWithVoids;
struct IfcTopologicalRepresentationItem;
struct IfcFace;
struct IfcFaceSurface;
struct IfcAdvancedFace;
struct IfcDistributionFlowElement;
struct IfcFlowTerminal;
struct IfcAirTerminal;
struct IfcFlowController;
struct IfcAirTerminalBox;
struct IfcDistributionFlowElementType;
struct IfcFlowControllerType;
struct IfcAirTerminalBoxType;
struct IfcFlowTerminalType;
struct IfcAirTerminalType;
struct IfcEnergyConversionDevice;
struct IfcAirToAirHeatRecovery;
struct IfcEnergyConversionDeviceType;
struct IfcAirToAirHeatRecoveryType;
struct IfcAlarm;
struct IfcAlarmType;
struct IfcAnnotation;
struct IfcAnnotationFillArea;
typedef NotImplemented IfcApplication; // (not currently used by Assimp)
typedef NotImplemented IfcAppliedValue; // (not currently used by Assimp)
typedef NotImplemented IfcApproval; // (not currently used by Assimp)
typedef NotImplemented IfcResourceLevelRelationship; // (not currently used by Assimp)
typedef NotImplemented IfcApprovalRelationship; // (not currently used by Assimp)
struct IfcProfileDef;
struct IfcArbitraryClosedProfileDef;
struct IfcArbitraryOpenProfileDef;
struct IfcArbitraryProfileDefWithVoids;
struct IfcGroup;
struct IfcAsset;
struct IfcParameterizedProfileDef;
struct IfcAsymmetricIShapeProfileDef;
struct IfcAudioVisualAppliance;
struct IfcAudioVisualApplianceType;
struct IfcPlacement;
struct IfcAxis1Placement;
struct IfcAxis2Placement2D;
struct IfcAxis2Placement3D;
struct IfcCurve;
struct IfcBoundedCurve;
struct IfcBSplineCurve;
struct IfcBSplineCurveWithKnots;
struct IfcSurface;
struct IfcBoundedSurface;
struct IfcBSplineSurface;
struct IfcBSplineSurfaceWithKnots;
struct IfcBuildingElement;
struct IfcBeam;
struct IfcBeamStandardCase;
struct IfcBuildingElementType;
struct IfcBeamType;
struct IfcPresentationItem;
typedef NotImplemented IfcSurfaceTexture; // (not currently used by Assimp)
typedef NotImplemented IfcBlobTexture; // (not currently used by Assimp)
struct IfcCsgPrimitive3D;
struct IfcBlock;
struct IfcBoiler;
struct IfcBoilerType;
struct IfcBooleanResult;
struct IfcBooleanClippingResult;
typedef NotImplemented IfcBoundaryCondition; // (not currently used by Assimp)
struct IfcCompositeCurve;
struct IfcCompositeCurveOnSurface;
struct IfcBoundaryCurve;
typedef NotImplemented IfcBoundaryEdgeCondition; // (not currently used by Assimp)
typedef NotImplemented IfcBoundaryFaceCondition; // (not currently used by Assimp)
typedef NotImplemented IfcBoundaryNodeCondition; // (not currently used by Assimp)
typedef NotImplemented IfcBoundaryNodeConditionWarping; // (not currently used by Assimp)
struct IfcBoundingBox;
struct IfcHalfSpaceSolid;
struct IfcBoxedHalfSpace;
struct IfcSpatialElement;
struct IfcSpatialStructureElement;
struct IfcBuilding;
struct IfcElementComponent;
struct IfcBuildingElementPart;
struct IfcElementComponentType;
struct IfcBuildingElementPartType;
struct IfcBuildingElementProxy;
struct IfcBuildingElementProxyType;
struct IfcBuildingStorey;
struct IfcSystem;
struct IfcBuildingSystem;
struct IfcBurner;
struct IfcBurnerType;
struct IfcCShapeProfileDef;
struct IfcFlowFitting;
struct IfcCableCarrierFitting;
struct IfcFlowFittingType;
struct IfcCableCarrierFittingType;
struct IfcFlowSegment;
struct IfcCableCarrierSegment;
struct IfcFlowSegmentType;
struct IfcCableCarrierSegmentType;
struct IfcCableFitting;
struct IfcCableFittingType;
struct IfcCableSegment;
struct IfcCableSegmentType;
struct IfcPoint;
struct IfcCartesianPoint;
struct IfcCartesianPointList;
struct IfcCartesianPointList2D;
struct IfcCartesianPointList3D;
struct IfcCartesianTransformationOperator;
struct IfcCartesianTransformationOperator2D;
struct IfcCartesianTransformationOperator2DnonUniform;
struct IfcCartesianTransformationOperator3D;
struct IfcCartesianTransformationOperator3DnonUniform;
struct IfcCenterLineProfileDef;
struct IfcChiller;
struct IfcChillerType;
struct IfcChimney;
struct IfcChimneyType;
struct IfcConic;
struct IfcCircle;
struct IfcCircleProfileDef;
struct IfcCircleHollowProfileDef;
struct IfcCivilElement;
struct IfcCivilElementType;
typedef NotImplemented IfcExternalInformation; // (not currently used by Assimp)
typedef NotImplemented IfcClassification; // (not currently used by Assimp)
typedef NotImplemented IfcExternalReference; // (not currently used by Assimp)
typedef NotImplemented IfcClassificationReference; // (not currently used by Assimp)
struct IfcConnectedFaceSet;
struct IfcClosedShell;
struct IfcCoil;
struct IfcCoilType;
struct IfcColourSpecification;
struct IfcColourRgb;
typedef NotImplemented IfcColourRgbList; // (not currently used by Assimp)
struct IfcColumn;
struct IfcColumnStandardCase;
struct IfcColumnType;
struct IfcCommunicationsAppliance;
struct IfcCommunicationsApplianceType;
struct IfcPropertyAbstraction;
struct IfcProperty;
struct IfcComplexProperty;
struct IfcPropertyDefinition;
typedef NotImplemented IfcPropertyTemplateDefinition; // (not currently used by Assimp)
typedef NotImplemented IfcPropertyTemplate; // (not currently used by Assimp)
typedef NotImplemented IfcComplexPropertyTemplate; // (not currently used by Assimp)
struct IfcCompositeCurveSegment;
struct IfcCompositeProfileDef;
struct IfcFlowMovingDevice;
struct IfcCompressor;
struct IfcFlowMovingDeviceType;
struct IfcCompressorType;
struct IfcCondenser;
struct IfcCondenserType;
typedef NotImplemented IfcConnectionGeometry; // (not currently used by Assimp)
typedef NotImplemented IfcConnectionCurveGeometry; // (not currently used by Assimp)
typedef NotImplemented IfcConnectionPointGeometry; // (not currently used by Assimp)
typedef NotImplemented IfcConnectionPointEccentricity; // (not currently used by Assimp)
typedef NotImplemented IfcConnectionSurfaceGeometry; // (not currently used by Assimp)
typedef NotImplemented IfcConnectionVolumeGeometry; // (not currently used by Assimp)
typedef NotImplemented IfcConstraint; // (not currently used by Assimp)
struct IfcResource;
struct IfcConstructionResource;
struct IfcConstructionEquipmentResource;
struct IfcTypeResource;
struct IfcConstructionResourceType;
struct IfcConstructionEquipmentResourceType;
struct IfcConstructionMaterialResource;
struct IfcConstructionMaterialResourceType;
struct IfcConstructionProductResource;
struct IfcConstructionProductResourceType;
struct IfcContext;
struct IfcNamedUnit;
struct IfcContextDependentUnit;
struct IfcController;
struct IfcControllerType;
struct IfcConversionBasedUnit;
struct IfcConversionBasedUnitWithOffset;
struct IfcCooledBeam;
struct IfcCooledBeamType;
struct IfcCoolingTower;
struct IfcCoolingTowerType;
typedef NotImplemented IfcCoordinateOperation; // (not currently used by Assimp)
typedef NotImplemented IfcCoordinateReferenceSystem; // (not currently used by Assimp)
struct IfcCostItem;
struct IfcCostSchedule;
typedef NotImplemented IfcCostValue; // (not currently used by Assimp)
struct IfcCovering;
struct IfcCoveringType;
struct IfcCrewResource;
struct IfcCrewResourceType;
struct IfcCsgSolid;
typedef NotImplemented IfcCurrencyRelationship; // (not currently used by Assimp)
struct IfcCurtainWall;
struct IfcCurtainWallType;
struct IfcCurveBoundedPlane;
struct IfcCurveBoundedSurface;
struct IfcPresentationStyle;
typedef NotImplemented IfcCurveStyle; // (not currently used by Assimp)
typedef NotImplemented IfcCurveStyleFont; // (not currently used by Assimp)
typedef NotImplemented IfcCurveStyleFontAndScaling; // (not currently used by Assimp)
typedef NotImplemented IfcCurveStyleFontPattern; // (not currently used by Assimp)
struct IfcElementarySurface;
struct IfcCylindricalSurface;
struct IfcDamper;
struct IfcDamperType;
struct IfcDerivedProfileDef;
typedef NotImplemented IfcDerivedUnit; // (not currently used by Assimp)
typedef NotImplemented IfcDerivedUnitElement; // (not currently used by Assimp)
typedef NotImplemented IfcDimensionalExponents; // (not currently used by Assimp)
struct IfcDirection;
struct IfcDiscreteAccessory;
struct IfcDiscreteAccessoryType;
struct IfcDistributionChamberElement;
struct IfcDistributionChamberElementType;
struct IfcDistributionSystem;
struct IfcDistributionCircuit;
struct IfcPort;
struct IfcDistributionPort;
typedef NotImplemented IfcDocumentInformation; // (not currently used by Assimp)
typedef NotImplemented IfcDocumentInformationRelationship; // (not currently used by Assimp)
typedef NotImplemented IfcDocumentReference; // (not currently used by Assimp)
struct IfcDoor;
struct IfcPropertySetDefinition;
typedef NotImplemented IfcPreDefinedPropertySet; // (not currently used by Assimp)
typedef NotImplemented IfcDoorLiningProperties; // (not currently used by Assimp)
typedef NotImplemented IfcDoorPanelProperties; // (not currently used by Assimp)
struct IfcDoorStandardCase;
struct IfcDoorStyle;
struct IfcDoorType;
typedef NotImplemented IfcPreDefinedItem; // (not currently used by Assimp)
typedef NotImplemented IfcPreDefinedColour; // (not currently used by Assimp)
typedef NotImplemented IfcDraughtingPreDefinedColour; // (not currently used by Assimp)
typedef NotImplemented IfcPreDefinedCurveFont; // (not currently used by Assimp)
typedef NotImplemented IfcDraughtingPreDefinedCurveFont; // (not currently used by Assimp)
struct IfcDuctFitting;
struct IfcDuctFittingType;
struct IfcDuctSegment;
struct IfcDuctSegmentType;
struct IfcFlowTreatmentDevice;
struct IfcDuctSilencer;
struct IfcFlowTreatmentDeviceType;
struct IfcDuctSilencerType;
struct IfcEdge;
struct IfcEdgeCurve;
struct IfcLoop;
struct IfcEdgeLoop;
struct IfcElectricAppliance;
struct IfcElectricApplianceType;
struct IfcElectricDistributionBoard;
struct IfcElectricDistributionBoardType;
struct IfcFlowStorageDevice;
struct IfcElectricFlowStorageDevice;
struct IfcFlowStorageDeviceType;
struct IfcElectricFlowStorageDeviceType;
struct IfcElectricGenerator;
struct IfcElectricGeneratorType;
struct IfcElectricMotor;
struct IfcElectricMotorType;
struct IfcElectricTimeControl;
struct IfcElectricTimeControlType;
struct IfcElementAssembly;
struct IfcElementAssemblyType;
struct IfcQuantitySet;
struct IfcElementQuantity;
struct IfcEllipse;
struct IfcEllipseProfileDef;
struct IfcEngine;
struct IfcEngineType;
struct IfcEvaporativeCooler;
struct IfcEvaporativeCoolerType;
struct IfcEvaporator;
struct IfcEvaporatorType;
struct IfcProcess;
struct IfcEvent;
typedef NotImplemented IfcSchedulingTime; // (not currently used by Assimp)
typedef NotImplemented IfcEventTime; // (not currently used by Assimp)
struct IfcTypeProcess;
struct IfcEventType;
typedef NotImplemented IfcExtendedProperties; // (not currently used by Assimp)
typedef NotImplemented IfcExternalReferenceRelationship; // (not currently used by Assimp)
struct IfcExternalSpatialStructureElement;
struct IfcExternalSpatialElement;
typedef NotImplemented IfcExternallyDefinedHatchStyle; // (not currently used by Assimp)
typedef NotImplemented IfcExternallyDefinedSurfaceStyle; // (not currently used by Assimp)
typedef NotImplemented IfcExternallyDefinedTextFont; // (not currently used by Assimp)
struct IfcSweptAreaSolid;
struct IfcExtrudedAreaSolid;
struct IfcExtrudedAreaSolidTapered;
struct IfcFaceBasedSurfaceModel;
struct IfcFaceBound;
struct IfcFaceOuterBound;
struct IfcFacetedBrep;
struct IfcFacetedBrepWithVoids;
typedef NotImplemented IfcStructuralConnectionCondition; // (not currently used by Assimp)
typedef NotImplemented IfcFailureConnectionCondition; // (not currently used by Assimp)
struct IfcFan;
struct IfcFanType;
struct IfcFastener;
struct IfcFastenerType;
struct IfcFeatureElement;
struct IfcFeatureElementAddition;
struct IfcFeatureElementSubtraction;
typedef NotImplemented IfcFillAreaStyle; // (not currently used by Assimp)
struct IfcFillAreaStyleHatching;
struct IfcFillAreaStyleTiles;
struct IfcFilter;
struct IfcFilterType;
struct IfcFireSuppressionTerminal;
struct IfcFireSuppressionTerminalType;
struct IfcFixedReferenceSweptAreaSolid;
struct IfcFlowInstrument;
struct IfcFlowInstrumentType;
struct IfcFlowMeter;
struct IfcFlowMeterType;
struct IfcFooting;
struct IfcFootingType;
struct IfcFurnishingElement;
struct IfcFurnishingElementType;
struct IfcFurniture;
struct IfcFurnitureType;
struct IfcGeographicElement;
struct IfcGeographicElementType;
struct IfcGeometricSet;
struct IfcGeometricCurveSet;
struct IfcRepresentationContext;
struct IfcGeometricRepresentationContext;
struct IfcGeometricRepresentationSubContext;
struct IfcGrid;
typedef NotImplemented IfcGridAxis; // (not currently used by Assimp)
struct IfcObjectPlacement;
struct IfcGridPlacement;
struct IfcHeatExchanger;
struct IfcHeatExchangerType;
struct IfcHumidifier;
struct IfcHumidifierType;
struct IfcIShapeProfileDef;
typedef NotImplemented IfcImageTexture; // (not currently used by Assimp)
typedef NotImplemented IfcIndexedColourMap; // (not currently used by Assimp)
struct IfcIndexedPolyCurve;
struct IfcTessellatedItem;
struct IfcIndexedPolygonalFace;
struct IfcIndexedPolygonalFaceWithVoids;
typedef NotImplemented IfcTextureCoordinate; // (not currently used by Assimp)
typedef NotImplemented IfcIndexedTextureMap; // (not currently used by Assimp)
typedef NotImplemented IfcIndexedTriangleTextureMap; // (not currently used by Assimp)
struct IfcInterceptor;
struct IfcInterceptorType;
struct IfcSurfaceCurve;
struct IfcIntersectionCurve;
struct IfcInventory;
typedef NotImplemented IfcTimeSeries; // (not currently used by Assimp)
typedef NotImplemented IfcIrregularTimeSeries; // (not currently used by Assimp)
typedef NotImplemented IfcIrregularTimeSeriesValue; // (not currently used by Assimp)
struct IfcJunctionBox;
struct IfcJunctionBoxType;
struct IfcLShapeProfileDef;
struct IfcLaborResource;
struct IfcLaborResourceType;
typedef NotImplemented IfcLagTime; // (not currently used by Assimp)
struct IfcLamp;
struct IfcLampType;
typedef NotImplemented IfcLibraryInformation; // (not currently used by Assimp)
typedef NotImplemented IfcLibraryReference; // (not currently used by Assimp)
typedef NotImplemented IfcLightDistributionData; // (not currently used by Assimp)
struct IfcLightFixture;
struct IfcLightFixtureType;
typedef NotImplemented IfcLightIntensityDistribution; // (not currently used by Assimp)
struct IfcLightSource;
struct IfcLightSourceAmbient;
struct IfcLightSourceDirectional;
struct IfcLightSourceGoniometric;
struct IfcLightSourcePositional;
struct IfcLightSourceSpot;
struct IfcLine;
struct IfcLocalPlacement;
typedef NotImplemented IfcMapConversion; // (not currently used by Assimp)
struct IfcMappedItem;
typedef NotImplemented IfcMaterialDefinition; // (not currently used by Assimp)
typedef NotImplemented IfcMaterial; // (not currently used by Assimp)
typedef NotImplemented IfcMaterialClassificationRelationship; // (not currently used by Assimp)
typedef NotImplemented IfcMaterialConstituent; // (not currently used by Assimp)
typedef NotImplemented IfcMaterialConstituentSet; // (not currently used by Assimp)
struct IfcProductRepresentation;
struct IfcMaterialDefinitionRepresentation;
typedef NotImplemented IfcMaterialLayer; // (not currently used by Assimp)
typedef NotImplemented IfcMaterialLayerSet; // (not currently used by Assimp)
typedef NotImplemented IfcMaterialUsageDefinition; // (not currently used by Assimp)
typedef NotImplemented IfcMaterialLayerSetUsage; // (not currently used by Assimp)
typedef NotImplemented IfcMaterialLayerWithOffsets; // (not currently used by Assimp)
typedef NotImplemented IfcMaterialList; // (not currently used by Assimp)
typedef NotImplemented IfcMaterialProfile; // (not currently used by Assimp)
typedef NotImplemented IfcMaterialProfileSet; // (not currently used by Assimp)
typedef NotImplemented IfcMaterialProfileSetUsage; // (not currently used by Assimp)
typedef NotImplemented IfcMaterialProfileSetUsageTapering; // (not currently used by Assimp)
typedef NotImplemented IfcMaterialProfileWithOffsets; // (not currently used by Assimp)
typedef NotImplemented IfcMaterialProperties; // (not currently used by Assimp)
typedef NotImplemented IfcMaterialRelationship; // (not currently used by Assimp)
struct IfcMeasureWithUnit;
struct IfcMechanicalFastener;
struct IfcMechanicalFastenerType;
struct IfcMedicalDevice;
struct IfcMedicalDeviceType;
struct IfcMember;
struct IfcMemberStandardCase;
struct IfcMemberType;
typedef NotImplemented IfcMetric; // (not currently used by Assimp)
struct IfcMirroredProfileDef;
typedef NotImplemented IfcMonetaryUnit; // (not currently used by Assimp)
struct IfcMotorConnection;
struct IfcMotorConnectionType;
typedef NotImplemented IfcObjective; // (not currently used by Assimp)
struct IfcOccupant;
struct IfcOffsetCurve2D;
struct IfcOffsetCurve3D;
struct IfcOpenShell;
struct IfcOpeningElement;
struct IfcOpeningStandardCase;
typedef NotImplemented IfcOrganization; // (not currently used by Assimp)
typedef NotImplemented IfcOrganizationRelationship; // (not currently used by Assimp)
struct IfcOrientedEdge;
struct IfcOuterBoundaryCurve;
struct IfcOutlet;
struct IfcOutletType;
typedef NotImplemented IfcOwnerHistory; // (not currently used by Assimp)
struct IfcPath;
struct IfcPcurve;
struct IfcPerformanceHistory;
typedef NotImplemented IfcPermeableCoveringProperties; // (not currently used by Assimp)
struct IfcPermit;
typedef NotImplemented IfcPerson; // (not currently used by Assimp)
typedef NotImplemented IfcPersonAndOrganization; // (not currently used by Assimp)
typedef NotImplemented IfcPhysicalQuantity; // (not currently used by Assimp)
typedef NotImplemented IfcPhysicalComplexQuantity; // (not currently used by Assimp)
typedef NotImplemented IfcPhysicalSimpleQuantity; // (not currently used by Assimp)
struct IfcPile;
struct IfcPileType;
struct IfcPipeFitting;
struct IfcPipeFittingType;
struct IfcPipeSegment;
struct IfcPipeSegmentType;
typedef NotImplemented IfcPixelTexture; // (not currently used by Assimp)
struct IfcPlanarExtent;
struct IfcPlanarBox;
struct IfcPlane;
struct IfcPlate;
struct IfcPlateStandardCase;
struct IfcPlateType;
struct IfcPointOnCurve;
struct IfcPointOnSurface;
struct IfcPolyLoop;
struct IfcPolygonalBoundedHalfSpace;
struct IfcTessellatedFaceSet;
struct IfcPolygonalFaceSet;
struct IfcPolyline;
typedef NotImplemented IfcPostalAddress; // (not currently used by Assimp)
typedef NotImplemented IfcPreDefinedProperties; // (not currently used by Assimp)
typedef NotImplemented IfcPreDefinedTextFont; // (not currently used by Assimp)
typedef NotImplemented IfcPresentationLayerAssignment; // (not currently used by Assimp)
typedef NotImplemented IfcPresentationLayerWithStyle; // (not currently used by Assimp)
struct IfcPresentationStyleAssignment;
struct IfcProcedure;
struct IfcProcedureType;
struct IfcProductDefinitionShape;
typedef NotImplemented IfcProfileProperties; // (not currently used by Assimp)
struct IfcProject;
struct IfcProjectLibrary;
struct IfcProjectOrder;
typedef NotImplemented IfcProjectedCRS; // (not currently used by Assimp)
struct IfcProjectionElement;
struct IfcSimpleProperty;
struct IfcPropertyBoundedValue;
typedef NotImplemented IfcPropertyDependencyRelationship; // (not currently used by Assimp)
struct IfcPropertyEnumeratedValue;
typedef NotImplemented IfcPropertyEnumeration; // (not currently used by Assimp)
struct IfcPropertyListValue;
struct IfcPropertyReferenceValue;
struct IfcPropertySet;
typedef NotImplemented IfcPropertySetTemplate; // (not currently used by Assimp)
struct IfcPropertySingleValue;
struct IfcPropertyTableValue;
struct IfcProtectiveDevice;
struct IfcProtectiveDeviceTrippingUnit;
struct IfcProtectiveDeviceTrippingUnitType;
struct IfcProtectiveDeviceType;
struct IfcProxy;
struct IfcPump;
struct IfcPumpType;
typedef NotImplemented IfcQuantityArea; // (not currently used by Assimp)
typedef NotImplemented IfcQuantityCount; // (not currently used by Assimp)
typedef NotImplemented IfcQuantityLength; // (not currently used by Assimp)
typedef NotImplemented IfcQuantityTime; // (not currently used by Assimp)
typedef NotImplemented IfcQuantityVolume; // (not currently used by Assimp)
typedef NotImplemented IfcQuantityWeight; // (not currently used by Assimp)
struct IfcRailing;
struct IfcRailingType;
struct IfcRamp;
struct IfcRampFlight;
struct IfcRampFlightType;
struct IfcRampType;
struct IfcRationalBSplineCurveWithKnots;
struct IfcRationalBSplineSurfaceWithKnots;
struct IfcRectangleProfileDef;
struct IfcRectangleHollowProfileDef;
struct IfcRectangularPyramid;
struct IfcRectangularTrimmedSurface;
typedef NotImplemented IfcRecurrencePattern; // (not currently used by Assimp)
typedef NotImplemented IfcReference; // (not currently used by Assimp)
typedef NotImplemented IfcRegularTimeSeries; // (not currently used by Assimp)
typedef NotImplemented IfcReinforcementBarProperties; // (not currently used by Assimp)
typedef NotImplemented IfcReinforcementDefinitionProperties; // (not currently used by Assimp)
struct IfcReinforcingElement;
struct IfcReinforcingBar;
struct IfcReinforcingElementType;
struct IfcReinforcingBarType;
struct IfcReinforcingMesh;
struct IfcReinforcingMeshType;
struct IfcRelationship;
struct IfcRelDecomposes;
struct IfcRelAggregates;
typedef NotImplemented IfcRelAssigns; // (not currently used by Assimp)
typedef NotImplemented IfcRelAssignsToActor; // (not currently used by Assimp)
typedef NotImplemented IfcRelAssignsToControl; // (not currently used by Assimp)
typedef NotImplemented IfcRelAssignsToGroup; // (not currently used by Assimp)
typedef NotImplemented IfcRelAssignsToGroupByFactor; // (not currently used by Assimp)
typedef NotImplemented IfcRelAssignsToProcess; // (not currently used by Assimp)
typedef NotImplemented IfcRelAssignsToProduct; // (not currently used by Assimp)
typedef NotImplemented IfcRelAssignsToResource; // (not currently used by Assimp)
typedef NotImplemented IfcRelAssociates; // (not currently used by Assimp)
typedef NotImplemented IfcRelAssociatesApproval; // (not currently used by Assimp)
typedef NotImplemented IfcRelAssociatesClassification; // (not currently used by Assimp)
typedef NotImplemented IfcRelAssociatesConstraint; // (not currently used by Assimp)
typedef NotImplemented IfcRelAssociatesDocument; // (not currently used by Assimp)
typedef NotImplemented IfcRelAssociatesLibrary; // (not currently used by Assimp)
typedef NotImplemented IfcRelAssociatesMaterial; // (not currently used by Assimp)
struct IfcRelConnects;
typedef NotImplemented IfcRelConnectsElements; // (not currently used by Assimp)
typedef NotImplemented IfcRelConnectsPathElements; // (not currently used by Assimp)
typedef NotImplemented IfcRelConnectsPortToElement; // (not currently used by Assimp)
typedef NotImplemented IfcRelConnectsPorts; // (not currently used by Assimp)
typedef NotImplemented IfcRelConnectsStructuralActivity; // (not currently used by Assimp)
typedef NotImplemented IfcRelConnectsStructuralMember; // (not currently used by Assimp)
typedef NotImplemented IfcRelConnectsWithEccentricity; // (not currently used by Assimp)
typedef NotImplemented IfcRelConnectsWithRealizingElements; // (not currently used by Assimp)
struct IfcRelContainedInSpatialStructure;
typedef NotImplemented IfcRelCoversBldgElements; // (not currently used by Assimp)
typedef NotImplemented IfcRelCoversSpaces; // (not currently used by Assimp)
typedef NotImplemented IfcRelDeclares; // (not currently used by Assimp)
struct IfcRelDefines;
typedef NotImplemented IfcRelDefinesByObject; // (not currently used by Assimp)
struct IfcRelDefinesByProperties;
typedef NotImplemented IfcRelDefinesByTemplate; // (not currently used by Assimp)
typedef NotImplemented IfcRelDefinesByType; // (not currently used by Assimp)
struct IfcRelFillsElement;
typedef NotImplemented IfcRelFlowControlElements; // (not currently used by Assimp)
typedef NotImplemented IfcRelInterferesElements; // (not currently used by Assimp)
typedef NotImplemented IfcRelNests; // (not currently used by Assimp)
typedef NotImplemented IfcRelProjectsElement; // (not currently used by Assimp)
typedef NotImplemented IfcRelReferencedInSpatialStructure; // (not currently used by Assimp)
typedef NotImplemented IfcRelSequence; // (not currently used by Assimp)
typedef NotImplemented IfcRelServicesBuildings; // (not currently used by Assimp)
typedef NotImplemented IfcRelSpaceBoundary; // (not currently used by Assimp)
typedef NotImplemented IfcRelSpaceBoundary1stLevel; // (not currently used by Assimp)
typedef NotImplemented IfcRelSpaceBoundary2ndLevel; // (not currently used by Assimp)
struct IfcRelVoidsElement;
struct IfcReparametrisedCompositeCurveSegment;
struct IfcRepresentation;
struct IfcRepresentationMap;
typedef NotImplemented IfcResourceApprovalRelationship; // (not currently used by Assimp)
typedef NotImplemented IfcResourceConstraintRelationship; // (not currently used by Assimp)
typedef NotImplemented IfcResourceTime; // (not currently used by Assimp)
struct IfcRevolvedAreaSolid;
struct IfcRevolvedAreaSolidTapered;
struct IfcRightCircularCone;
struct IfcRightCircularCylinder;
struct IfcRoof;
struct IfcRoofType;
struct IfcRoundedRectangleProfileDef;
struct IfcSIUnit;
struct IfcSanitaryTerminal;
struct IfcSanitaryTerminalType;
struct IfcSeamCurve;
typedef NotImplemented IfcSectionProperties; // (not currently used by Assimp)
typedef NotImplemented IfcSectionReinforcementProperties; // (not currently used by Assimp)
struct IfcSectionedSpine;
struct IfcSensor;
struct IfcSensorType;
struct IfcShadingDevice;
struct IfcShadingDeviceType;
typedef NotImplemented IfcShapeAspect; // (not currently used by Assimp)
struct IfcShapeModel;
struct IfcShapeRepresentation;
struct IfcShellBasedSurfaceModel;
typedef NotImplemented IfcSimplePropertyTemplate; // (not currently used by Assimp)
struct IfcSite;
struct IfcSlab;
struct IfcSlabElementedCase;
struct IfcSlabStandardCase;
struct IfcSlabType;
typedef NotImplemented IfcSlippageConnectionCondition; // (not currently used by Assimp)
struct IfcSolarDevice;
struct IfcSolarDeviceType;
struct IfcSpace;
struct IfcSpaceHeater;
struct IfcSpaceHeaterType;
struct IfcSpatialElementType;
struct IfcSpatialStructureElementType;
struct IfcSpaceType;
struct IfcSpatialZone;
struct IfcSpatialZoneType;
struct IfcSphere;
struct IfcSphericalSurface;
struct IfcStackTerminal;
struct IfcStackTerminalType;
struct IfcStair;
struct IfcStairFlight;
struct IfcStairFlightType;
struct IfcStairType;
struct IfcStructuralActivity;
struct IfcStructuralAction;
struct IfcStructuralAnalysisModel;
struct IfcStructuralItem;
struct IfcStructuralConnection;
struct IfcStructuralCurveAction;
struct IfcStructuralCurveConnection;
struct IfcStructuralMember;
struct IfcStructuralCurveMember;
struct IfcStructuralCurveMemberVarying;
struct IfcStructuralReaction;
struct IfcStructuralCurveReaction;
struct IfcStructuralLinearAction;
typedef NotImplemented IfcStructuralLoad; // (not currently used by Assimp)
struct IfcStructuralLoadGroup;
struct IfcStructuralLoadCase;
typedef NotImplemented IfcStructuralLoadConfiguration; // (not currently used by Assimp)
typedef NotImplemented IfcStructuralLoadOrResult; // (not currently used by Assimp)
typedef NotImplemented IfcStructuralLoadStatic; // (not currently used by Assimp)
typedef NotImplemented IfcStructuralLoadLinearForce; // (not currently used by Assimp)
typedef NotImplemented IfcStructuralLoadPlanarForce; // (not currently used by Assimp)
typedef NotImplemented IfcStructuralLoadSingleDisplacement; // (not currently used by Assimp)
typedef NotImplemented IfcStructuralLoadSingleDisplacementDistortion; // (not currently used by Assimp)
typedef NotImplemented IfcStructuralLoadSingleForce; // (not currently used by Assimp)
typedef NotImplemented IfcStructuralLoadSingleForceWarping; // (not currently used by Assimp)
typedef NotImplemented IfcStructuralLoadTemperature; // (not currently used by Assimp)
struct IfcStructuralSurfaceAction;
struct IfcStructuralPlanarAction;
struct IfcStructuralPointAction;
struct IfcStructuralPointConnection;
struct IfcStructuralPointReaction;
struct IfcStructuralResultGroup;
struct IfcStructuralSurfaceConnection;
struct IfcStructuralSurfaceMember;
struct IfcStructuralSurfaceMemberVarying;
struct IfcStructuralSurfaceReaction;
struct IfcStyleModel;
struct IfcStyledItem;
struct IfcStyledRepresentation;
struct IfcSubContractResource;
struct IfcSubContractResourceType;
struct IfcSubedge;
struct IfcSurfaceCurveSweptAreaSolid;
struct IfcSurfaceFeature;
struct IfcSweptSurface;
struct IfcSurfaceOfLinearExtrusion;
struct IfcSurfaceOfRevolution;
typedef NotImplemented IfcSurfaceReinforcementArea; // (not currently used by Assimp)
struct IfcSurfaceStyle;
typedef NotImplemented IfcSurfaceStyleLighting; // (not currently used by Assimp)
typedef NotImplemented IfcSurfaceStyleRefraction; // (not currently used by Assimp)
struct IfcSurfaceStyleShading;
struct IfcSurfaceStyleRendering;
struct IfcSurfaceStyleWithTextures;
struct IfcSweptDiskSolid;
struct IfcSweptDiskSolidPolygonal;
struct IfcSwitchingDevice;
struct IfcSwitchingDeviceType;
struct IfcSystemFurnitureElement;
struct IfcSystemFurnitureElementType;
struct IfcTShapeProfileDef;
typedef NotImplemented IfcTable; // (not currently used by Assimp)
typedef NotImplemented IfcTableColumn; // (not currently used by Assimp)
typedef NotImplemented IfcTableRow; // (not currently used by Assimp)
struct IfcTank;
struct IfcTankType;
struct IfcTask;
typedef NotImplemented IfcTaskTime; // (not currently used by Assimp)
typedef NotImplemented IfcTaskTimeRecurring; // (not currently used by Assimp)
struct IfcTaskType;
typedef NotImplemented IfcTelecomAddress; // (not currently used by Assimp)
struct IfcTendon;
struct IfcTendonAnchor;
struct IfcTendonAnchorType;
struct IfcTendonType;
struct IfcTextLiteral;
struct IfcTextLiteralWithExtent;
typedef NotImplemented IfcTextStyle; // (not currently used by Assimp)
typedef NotImplemented IfcTextStyleFontModel; // (not currently used by Assimp)
typedef NotImplemented IfcTextStyleForDefinedFont; // (not currently used by Assimp)
typedef NotImplemented IfcTextStyleTextModel; // (not currently used by Assimp)
typedef NotImplemented IfcTextureCoordinateGenerator; // (not currently used by Assimp)
typedef NotImplemented IfcTextureMap; // (not currently used by Assimp)
typedef NotImplemented IfcTextureVertex; // (not currently used by Assimp)
typedef NotImplemented IfcTextureVertexList; // (not currently used by Assimp)
typedef NotImplemented IfcTimePeriod; // (not currently used by Assimp)
typedef NotImplemented IfcTimeSeriesValue; // (not currently used by Assimp)
struct IfcTopologyRepresentation;
struct IfcToroidalSurface;
struct IfcTransformer;
struct IfcTransformerType;
struct IfcTransportElement;
struct IfcTransportElementType;
struct IfcTrapeziumProfileDef;
struct IfcTriangulatedFaceSet;
struct IfcTrimmedCurve;
struct IfcTubeBundle;
struct IfcTubeBundleType;
struct IfcUShapeProfileDef;
struct IfcUnitAssignment;
struct IfcUnitaryControlElement;
struct IfcUnitaryControlElementType;
struct IfcUnitaryEquipment;
struct IfcUnitaryEquipmentType;
struct IfcValve;
struct IfcValveType;
struct IfcVector;
struct IfcVertex;
struct IfcVertexLoop;
struct IfcVertexPoint;
struct IfcVibrationIsolator;
struct IfcVibrationIsolatorType;
struct IfcVirtualElement;
typedef NotImplemented IfcVirtualGridIntersection; // (not currently used by Assimp)
struct IfcVoidingFeature;
struct IfcWall;
struct IfcWallElementedCase;
struct IfcWallStandardCase;
struct IfcWallType;
struct IfcWasteTerminal;
struct IfcWasteTerminalType;
struct IfcWindow;
typedef NotImplemented IfcWindowLiningProperties; // (not currently used by Assimp)
typedef NotImplemented IfcWindowPanelProperties; // (not currently used by Assimp)
struct IfcWindowStandardCase;
struct IfcWindowStyle;
struct IfcWindowType;
struct IfcWorkCalendar;
struct IfcWorkControl;
struct IfcWorkPlan;
struct IfcWorkSchedule;
typedef NotImplemented IfcWorkTime; // (not currently used by Assimp)
struct IfcZShapeProfileDef;
struct IfcZone;
// C++ wrapper for IfcRoot
struct IfcRoot : ObjectHelper<IfcRoot,4> { IfcRoot() : Object("IfcRoot") {}
IfcGloballyUniqueId::Out GlobalId;
Maybe< Lazy< NotImplemented > > OwnerHistory;
Maybe< IfcLabel::Out > Name;
Maybe< IfcText::Out > Description;
};
// C++ wrapper for IfcObjectDefinition
struct IfcObjectDefinition : IfcRoot, ObjectHelper<IfcObjectDefinition,0> { IfcObjectDefinition() : Object("IfcObjectDefinition") {}
};
// C++ wrapper for IfcObject
struct IfcObject : IfcObjectDefinition, ObjectHelper<IfcObject,1> { IfcObject() : Object("IfcObject") {}
Maybe< IfcLabel::Out > ObjectType;
};
// C++ wrapper for IfcControl
struct IfcControl : IfcObject, ObjectHelper<IfcControl,1> { IfcControl() : Object("IfcControl") {}
Maybe< IfcIdentifier::Out > Identification;
};
// C++ wrapper for IfcActionRequest
struct IfcActionRequest : IfcControl, ObjectHelper<IfcActionRequest,3> { IfcActionRequest() : Object("IfcActionRequest") {}
Maybe< IfcActionRequestTypeEnum::Out > PredefinedType;
Maybe< IfcLabel::Out > Status;
Maybe< IfcText::Out > LongDescription;
};
// C++ wrapper for IfcActor
struct IfcActor : IfcObject, ObjectHelper<IfcActor,1> { IfcActor() : Object("IfcActor") {}
IfcActorSelect::Out TheActor;
};
// C++ wrapper for IfcProduct
struct IfcProduct : IfcObject, ObjectHelper<IfcProduct,2> { IfcProduct() : Object("IfcProduct") {}
Maybe< Lazy< IfcObjectPlacement > > ObjectPlacement;
Maybe< Lazy< IfcProductRepresentation > > Representation;
};
// C++ wrapper for IfcElement
struct IfcElement : IfcProduct, ObjectHelper<IfcElement,1> { IfcElement() : Object("IfcElement") {}
Maybe< IfcIdentifier::Out > Tag;
};
// C++ wrapper for IfcDistributionElement
struct IfcDistributionElement : IfcElement, ObjectHelper<IfcDistributionElement,0> { IfcDistributionElement() : Object("IfcDistributionElement") {}
};
// C++ wrapper for IfcDistributionControlElement
struct IfcDistributionControlElement : IfcDistributionElement, ObjectHelper<IfcDistributionControlElement,0> { IfcDistributionControlElement() : Object("IfcDistributionControlElement") {}
};
// C++ wrapper for IfcActuator
struct IfcActuator : IfcDistributionControlElement, ObjectHelper<IfcActuator,1> { IfcActuator() : Object("IfcActuator") {}
Maybe< IfcActuatorTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcTypeObject
struct IfcTypeObject : IfcObjectDefinition, ObjectHelper<IfcTypeObject,2> { IfcTypeObject() : Object("IfcTypeObject") {}
Maybe< IfcIdentifier::Out > ApplicableOccurrence;
Maybe< ListOf< Lazy< IfcPropertySetDefinition >, 1, 0 > > HasPropertySets;
};
// C++ wrapper for IfcTypeProduct
struct IfcTypeProduct : IfcTypeObject, ObjectHelper<IfcTypeProduct,2> { IfcTypeProduct() : Object("IfcTypeProduct") {}
Maybe< ListOf< Lazy< IfcRepresentationMap >, 1, 0 > > RepresentationMaps;
Maybe< IfcLabel::Out > Tag;
};
// C++ wrapper for IfcElementType
struct IfcElementType : IfcTypeProduct, ObjectHelper<IfcElementType,1> { IfcElementType() : Object("IfcElementType") {}
Maybe< IfcLabel::Out > ElementType;
};
// C++ wrapper for IfcDistributionElementType
struct IfcDistributionElementType : IfcElementType, ObjectHelper<IfcDistributionElementType,0> { IfcDistributionElementType() : Object("IfcDistributionElementType") {}
};
// C++ wrapper for IfcDistributionControlElementType
struct IfcDistributionControlElementType : IfcDistributionElementType, ObjectHelper<IfcDistributionControlElementType,0> { IfcDistributionControlElementType() : Object("IfcDistributionControlElementType") {}
};
// C++ wrapper for IfcActuatorType
struct IfcActuatorType : IfcDistributionControlElementType, ObjectHelper<IfcActuatorType,1> { IfcActuatorType() : Object("IfcActuatorType") {}
IfcActuatorTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcRepresentationItem
struct IfcRepresentationItem : ObjectHelper<IfcRepresentationItem,0> { IfcRepresentationItem() : Object("IfcRepresentationItem") {}
};
// C++ wrapper for IfcGeometricRepresentationItem
struct IfcGeometricRepresentationItem : IfcRepresentationItem, ObjectHelper<IfcGeometricRepresentationItem,0> { IfcGeometricRepresentationItem() : Object("IfcGeometricRepresentationItem") {}
};
// C++ wrapper for IfcSolidModel
struct IfcSolidModel : IfcGeometricRepresentationItem, ObjectHelper<IfcSolidModel,0> { IfcSolidModel() : Object("IfcSolidModel") {}
};
// C++ wrapper for IfcManifoldSolidBrep
struct IfcManifoldSolidBrep : IfcSolidModel, ObjectHelper<IfcManifoldSolidBrep,1> { IfcManifoldSolidBrep() : Object("IfcManifoldSolidBrep") {}
Lazy< IfcClosedShell > Outer;
};
// C++ wrapper for IfcAdvancedBrep
struct IfcAdvancedBrep : IfcManifoldSolidBrep, ObjectHelper<IfcAdvancedBrep,0> { IfcAdvancedBrep() : Object("IfcAdvancedBrep") {}
};
// C++ wrapper for IfcAdvancedBrepWithVoids
struct IfcAdvancedBrepWithVoids : IfcAdvancedBrep, ObjectHelper<IfcAdvancedBrepWithVoids,1> { IfcAdvancedBrepWithVoids() : Object("IfcAdvancedBrepWithVoids") {}
ListOf< Lazy< IfcClosedShell >, 1, 0 > Voids;
};
// C++ wrapper for IfcTopologicalRepresentationItem
struct IfcTopologicalRepresentationItem : IfcRepresentationItem, ObjectHelper<IfcTopologicalRepresentationItem,0> { IfcTopologicalRepresentationItem() : Object("IfcTopologicalRepresentationItem") {}
};
// C++ wrapper for IfcFace
struct IfcFace : IfcTopologicalRepresentationItem, ObjectHelper<IfcFace,1> { IfcFace() : Object("IfcFace") {}
ListOf< Lazy< IfcFaceBound >, 1, 0 > Bounds;
};
// C++ wrapper for IfcFaceSurface
struct IfcFaceSurface : IfcFace, ObjectHelper<IfcFaceSurface,2> { IfcFaceSurface() : Object("IfcFaceSurface") {}
Lazy< IfcSurface > FaceSurface;
IfcBoolean::Out SameSense;
};
// C++ wrapper for IfcAdvancedFace
struct IfcAdvancedFace : IfcFaceSurface, ObjectHelper<IfcAdvancedFace,0> { IfcAdvancedFace() : Object("IfcAdvancedFace") {}
};
// C++ wrapper for IfcDistributionFlowElement
struct IfcDistributionFlowElement : IfcDistributionElement, ObjectHelper<IfcDistributionFlowElement,0> { IfcDistributionFlowElement() : Object("IfcDistributionFlowElement") {}
};
// C++ wrapper for IfcFlowTerminal
struct IfcFlowTerminal : IfcDistributionFlowElement, ObjectHelper<IfcFlowTerminal,0> { IfcFlowTerminal() : Object("IfcFlowTerminal") {}
};
// C++ wrapper for IfcAirTerminal
struct IfcAirTerminal : IfcFlowTerminal, ObjectHelper<IfcAirTerminal,1> { IfcAirTerminal() : Object("IfcAirTerminal") {}
Maybe< IfcAirTerminalTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcFlowController
struct IfcFlowController : IfcDistributionFlowElement, ObjectHelper<IfcFlowController,0> { IfcFlowController() : Object("IfcFlowController") {}
};
// C++ wrapper for IfcAirTerminalBox
struct IfcAirTerminalBox : IfcFlowController, ObjectHelper<IfcAirTerminalBox,1> { IfcAirTerminalBox() : Object("IfcAirTerminalBox") {}
Maybe< IfcAirTerminalBoxTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcDistributionFlowElementType
struct IfcDistributionFlowElementType : IfcDistributionElementType, ObjectHelper<IfcDistributionFlowElementType,0> { IfcDistributionFlowElementType() : Object("IfcDistributionFlowElementType") {}
};
// C++ wrapper for IfcFlowControllerType
struct IfcFlowControllerType : IfcDistributionFlowElementType, ObjectHelper<IfcFlowControllerType,0> { IfcFlowControllerType() : Object("IfcFlowControllerType") {}
};
// C++ wrapper for IfcAirTerminalBoxType
struct IfcAirTerminalBoxType : IfcFlowControllerType, ObjectHelper<IfcAirTerminalBoxType,1> { IfcAirTerminalBoxType() : Object("IfcAirTerminalBoxType") {}
IfcAirTerminalBoxTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcFlowTerminalType
struct IfcFlowTerminalType : IfcDistributionFlowElementType, ObjectHelper<IfcFlowTerminalType,0> { IfcFlowTerminalType() : Object("IfcFlowTerminalType") {}
};
// C++ wrapper for IfcAirTerminalType
struct IfcAirTerminalType : IfcFlowTerminalType, ObjectHelper<IfcAirTerminalType,1> { IfcAirTerminalType() : Object("IfcAirTerminalType") {}
IfcAirTerminalTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcEnergyConversionDevice
struct IfcEnergyConversionDevice : IfcDistributionFlowElement, ObjectHelper<IfcEnergyConversionDevice,0> { IfcEnergyConversionDevice() : Object("IfcEnergyConversionDevice") {}
};
// C++ wrapper for IfcAirToAirHeatRecovery
struct IfcAirToAirHeatRecovery : IfcEnergyConversionDevice, ObjectHelper<IfcAirToAirHeatRecovery,1> { IfcAirToAirHeatRecovery() : Object("IfcAirToAirHeatRecovery") {}
Maybe< IfcAirToAirHeatRecoveryTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcEnergyConversionDeviceType
struct IfcEnergyConversionDeviceType : IfcDistributionFlowElementType, ObjectHelper<IfcEnergyConversionDeviceType,0> { IfcEnergyConversionDeviceType() : Object("IfcEnergyConversionDeviceType") {}
};
// C++ wrapper for IfcAirToAirHeatRecoveryType
struct IfcAirToAirHeatRecoveryType : IfcEnergyConversionDeviceType, ObjectHelper<IfcAirToAirHeatRecoveryType,1> { IfcAirToAirHeatRecoveryType() : Object("IfcAirToAirHeatRecoveryType") {}
IfcAirToAirHeatRecoveryTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcAlarm
struct IfcAlarm : IfcDistributionControlElement, ObjectHelper<IfcAlarm,1> { IfcAlarm() : Object("IfcAlarm") {}
Maybe< IfcAlarmTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcAlarmType
struct IfcAlarmType : IfcDistributionControlElementType, ObjectHelper<IfcAlarmType,1> { IfcAlarmType() : Object("IfcAlarmType") {}
IfcAlarmTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcAnnotation
struct IfcAnnotation : IfcProduct, ObjectHelper<IfcAnnotation,0> { IfcAnnotation() : Object("IfcAnnotation") {}
};
// C++ wrapper for IfcAnnotationFillArea
struct IfcAnnotationFillArea : IfcGeometricRepresentationItem, ObjectHelper<IfcAnnotationFillArea,2> { IfcAnnotationFillArea() : Object("IfcAnnotationFillArea") {}
Lazy< IfcCurve > OuterBoundary;
Maybe< ListOf< Lazy< IfcCurve >, 1, 0 > > InnerBoundaries;
};
// C++ wrapper for IfcProfileDef
struct IfcProfileDef : ObjectHelper<IfcProfileDef,2> { IfcProfileDef() : Object("IfcProfileDef") {}
IfcProfileTypeEnum::Out ProfileType;
Maybe< IfcLabel::Out > ProfileName;
};
// C++ wrapper for IfcArbitraryClosedProfileDef
struct IfcArbitraryClosedProfileDef : IfcProfileDef, ObjectHelper<IfcArbitraryClosedProfileDef,1> { IfcArbitraryClosedProfileDef() : Object("IfcArbitraryClosedProfileDef") {}
Lazy< IfcCurve > OuterCurve;
};
// C++ wrapper for IfcArbitraryOpenProfileDef
struct IfcArbitraryOpenProfileDef : IfcProfileDef, ObjectHelper<IfcArbitraryOpenProfileDef,1> { IfcArbitraryOpenProfileDef() : Object("IfcArbitraryOpenProfileDef") {}
Lazy< IfcBoundedCurve > Curve;
};
// C++ wrapper for IfcArbitraryProfileDefWithVoids
struct IfcArbitraryProfileDefWithVoids : IfcArbitraryClosedProfileDef, ObjectHelper<IfcArbitraryProfileDefWithVoids,1> { IfcArbitraryProfileDefWithVoids() : Object("IfcArbitraryProfileDefWithVoids") {}
ListOf< Lazy< IfcCurve >, 1, 0 > InnerCurves;
};
// C++ wrapper for IfcGroup
struct IfcGroup : IfcObject, ObjectHelper<IfcGroup,0> { IfcGroup() : Object("IfcGroup") {}
};
// C++ wrapper for IfcAsset
struct IfcAsset : IfcGroup, ObjectHelper<IfcAsset,9> { IfcAsset() : Object("IfcAsset") {}
Maybe< IfcIdentifier::Out > Identification;
Maybe< Lazy< NotImplemented > > OriginalValue;
Maybe< Lazy< NotImplemented > > CurrentValue;
Maybe< Lazy< NotImplemented > > TotalReplacementCost;
Maybe< IfcActorSelect::Out > Owner;
Maybe< IfcActorSelect::Out > User;
Maybe< Lazy< NotImplemented > > ResponsiblePerson;
Maybe< IfcDate::Out > IncorporationDate;
Maybe< Lazy< NotImplemented > > DepreciatedValue;
};
// C++ wrapper for IfcParameterizedProfileDef
struct IfcParameterizedProfileDef : IfcProfileDef, ObjectHelper<IfcParameterizedProfileDef,1> { IfcParameterizedProfileDef() : Object("IfcParameterizedProfileDef") {}
Maybe< Lazy< IfcAxis2Placement2D > > Position;
};
// C++ wrapper for IfcAsymmetricIShapeProfileDef
struct IfcAsymmetricIShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcAsymmetricIShapeProfileDef,12> { IfcAsymmetricIShapeProfileDef() : Object("IfcAsymmetricIShapeProfileDef") {}
IfcPositiveLengthMeasure::Out BottomFlangeWidth;
IfcPositiveLengthMeasure::Out OverallDepth;
IfcPositiveLengthMeasure::Out WebThickness;
IfcPositiveLengthMeasure::Out BottomFlangeThickness;
Maybe< IfcNonNegativeLengthMeasure::Out > BottomFlangeFilletRadius;
IfcPositiveLengthMeasure::Out TopFlangeWidth;
Maybe< IfcPositiveLengthMeasure::Out > TopFlangeThickness;
Maybe< IfcNonNegativeLengthMeasure::Out > TopFlangeFilletRadius;
Maybe< IfcNonNegativeLengthMeasure::Out > BottomFlangeEdgeRadius;
Maybe< IfcPlaneAngleMeasure::Out > BottomFlangeSlope;
Maybe< IfcNonNegativeLengthMeasure::Out > TopFlangeEdgeRadius;
Maybe< IfcPlaneAngleMeasure::Out > TopFlangeSlope;
};
// C++ wrapper for IfcAudioVisualAppliance
struct IfcAudioVisualAppliance : IfcFlowTerminal, ObjectHelper<IfcAudioVisualAppliance,1> { IfcAudioVisualAppliance() : Object("IfcAudioVisualAppliance") {}
Maybe< IfcAudioVisualApplianceTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcAudioVisualApplianceType
struct IfcAudioVisualApplianceType : IfcFlowTerminalType, ObjectHelper<IfcAudioVisualApplianceType,1> { IfcAudioVisualApplianceType() : Object("IfcAudioVisualApplianceType") {}
IfcAudioVisualApplianceTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcPlacement
struct IfcPlacement : IfcGeometricRepresentationItem, ObjectHelper<IfcPlacement,1> { IfcPlacement() : Object("IfcPlacement") {}
Lazy< IfcCartesianPoint > Location;
};
// C++ wrapper for IfcAxis1Placement
struct IfcAxis1Placement : IfcPlacement, ObjectHelper<IfcAxis1Placement,1> { IfcAxis1Placement() : Object("IfcAxis1Placement") {}
Maybe< Lazy< IfcDirection > > Axis;
};
// C++ wrapper for IfcAxis2Placement2D
struct IfcAxis2Placement2D : IfcPlacement, ObjectHelper<IfcAxis2Placement2D,1> { IfcAxis2Placement2D() : Object("IfcAxis2Placement2D") {}
Maybe< Lazy< IfcDirection > > RefDirection;
};
// C++ wrapper for IfcAxis2Placement3D
struct IfcAxis2Placement3D : IfcPlacement, ObjectHelper<IfcAxis2Placement3D,2> { IfcAxis2Placement3D() : Object("IfcAxis2Placement3D") {}
Maybe< Lazy< IfcDirection > > Axis;
Maybe< Lazy< IfcDirection > > RefDirection;
};
// C++ wrapper for IfcCurve
struct IfcCurve : IfcGeometricRepresentationItem, ObjectHelper<IfcCurve,0> { IfcCurve() : Object("IfcCurve") {}
};
// C++ wrapper for IfcBoundedCurve
struct IfcBoundedCurve : IfcCurve, ObjectHelper<IfcBoundedCurve,0> { IfcBoundedCurve() : Object("IfcBoundedCurve") {}
};
// C++ wrapper for IfcBSplineCurve
struct IfcBSplineCurve : IfcBoundedCurve, ObjectHelper<IfcBSplineCurve,5> { IfcBSplineCurve() : Object("IfcBSplineCurve") {}
IfcInteger::Out Degree;
ListOf< Lazy< IfcCartesianPoint >, 2, 0 > ControlPointsList;
IfcBSplineCurveForm::Out CurveForm;
IfcLogical::Out ClosedCurve;
IfcLogical::Out SelfIntersect;
};
// C++ wrapper for IfcBSplineCurveWithKnots
struct IfcBSplineCurveWithKnots : IfcBSplineCurve, ObjectHelper<IfcBSplineCurveWithKnots,3> { IfcBSplineCurveWithKnots() : Object("IfcBSplineCurveWithKnots") {}
ListOf< IfcInteger, 2, 0 >::Out KnotMultiplicities;
ListOf< IfcParameterValue, 2, 0 >::Out Knots;
IfcKnotType::Out KnotSpec;
};
// C++ wrapper for IfcSurface
struct IfcSurface : IfcGeometricRepresentationItem, ObjectHelper<IfcSurface,0> { IfcSurface() : Object("IfcSurface") {}
};
// C++ wrapper for IfcBoundedSurface
struct IfcBoundedSurface : IfcSurface, ObjectHelper<IfcBoundedSurface,0> { IfcBoundedSurface() : Object("IfcBoundedSurface") {}
};
// C++ wrapper for IfcBSplineSurface
struct IfcBSplineSurface : IfcBoundedSurface, ObjectHelper<IfcBSplineSurface,6> { IfcBSplineSurface() : Object("IfcBSplineSurface") {}
IfcInteger::Out UDegree;
IfcInteger::Out VDegree;
IfcBSplineSurfaceForm::Out SurfaceForm;
IfcLogical::Out UClosed;
IfcLogical::Out VClosed;
IfcLogical::Out SelfIntersect;
};
// C++ wrapper for IfcBSplineSurfaceWithKnots
struct IfcBSplineSurfaceWithKnots : IfcBSplineSurface, ObjectHelper<IfcBSplineSurfaceWithKnots,5> { IfcBSplineSurfaceWithKnots() : Object("IfcBSplineSurfaceWithKnots") {}
ListOf< IfcInteger, 2, 0 >::Out UMultiplicities;
ListOf< IfcInteger, 2, 0 >::Out VMultiplicities;
ListOf< IfcParameterValue, 2, 0 >::Out UKnots;
ListOf< IfcParameterValue, 2, 0 >::Out VKnots;
IfcKnotType::Out KnotSpec;
};
// C++ wrapper for IfcBuildingElement
struct IfcBuildingElement : IfcElement, ObjectHelper<IfcBuildingElement,0> { IfcBuildingElement() : Object("IfcBuildingElement") {}
};
// C++ wrapper for IfcBeam
struct IfcBeam : IfcBuildingElement, ObjectHelper<IfcBeam,1> { IfcBeam() : Object("IfcBeam") {}
Maybe< IfcBeamTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcBeamStandardCase
struct IfcBeamStandardCase : IfcBeam, ObjectHelper<IfcBeamStandardCase,0> { IfcBeamStandardCase() : Object("IfcBeamStandardCase") {}
};
// C++ wrapper for IfcBuildingElementType
struct IfcBuildingElementType : IfcElementType, ObjectHelper<IfcBuildingElementType,0> { IfcBuildingElementType() : Object("IfcBuildingElementType") {}
};
// C++ wrapper for IfcBeamType
struct IfcBeamType : IfcBuildingElementType, ObjectHelper<IfcBeamType,1> { IfcBeamType() : Object("IfcBeamType") {}
IfcBeamTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcPresentationItem
struct IfcPresentationItem : ObjectHelper<IfcPresentationItem,0> { IfcPresentationItem() : Object("IfcPresentationItem") {}
};
// C++ wrapper for IfcCsgPrimitive3D
struct IfcCsgPrimitive3D : IfcGeometricRepresentationItem, ObjectHelper<IfcCsgPrimitive3D,1> { IfcCsgPrimitive3D() : Object("IfcCsgPrimitive3D") {}
Lazy< IfcAxis2Placement3D > Position;
};
// C++ wrapper for IfcBlock
struct IfcBlock : IfcCsgPrimitive3D, ObjectHelper<IfcBlock,3> { IfcBlock() : Object("IfcBlock") {}
IfcPositiveLengthMeasure::Out XLength;
IfcPositiveLengthMeasure::Out YLength;
IfcPositiveLengthMeasure::Out ZLength;
};
// C++ wrapper for IfcBoiler
struct IfcBoiler : IfcEnergyConversionDevice, ObjectHelper<IfcBoiler,1> { IfcBoiler() : Object("IfcBoiler") {}
Maybe< IfcBoilerTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcBoilerType
struct IfcBoilerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcBoilerType,1> { IfcBoilerType() : Object("IfcBoilerType") {}
IfcBoilerTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcBooleanResult
struct IfcBooleanResult : IfcGeometricRepresentationItem, ObjectHelper<IfcBooleanResult,3> { IfcBooleanResult() : Object("IfcBooleanResult") {}
IfcBooleanOperator::Out Operator;
IfcBooleanOperand::Out FirstOperand;
IfcBooleanOperand::Out SecondOperand;
};
// C++ wrapper for IfcBooleanClippingResult
struct IfcBooleanClippingResult : IfcBooleanResult, ObjectHelper<IfcBooleanClippingResult,0> { IfcBooleanClippingResult() : Object("IfcBooleanClippingResult") {}
};
// C++ wrapper for IfcCompositeCurve
struct IfcCompositeCurve : IfcBoundedCurve, ObjectHelper<IfcCompositeCurve,2> { IfcCompositeCurve() : Object("IfcCompositeCurve") {}
ListOf< Lazy< IfcCompositeCurveSegment >, 1, 0 > Segments;
IfcLogical::Out SelfIntersect;
};
// C++ wrapper for IfcCompositeCurveOnSurface
struct IfcCompositeCurveOnSurface : IfcCompositeCurve, ObjectHelper<IfcCompositeCurveOnSurface,0> { IfcCompositeCurveOnSurface() : Object("IfcCompositeCurveOnSurface") {}
};
// C++ wrapper for IfcBoundaryCurve
struct IfcBoundaryCurve : IfcCompositeCurveOnSurface, ObjectHelper<IfcBoundaryCurve,0> { IfcBoundaryCurve() : Object("IfcBoundaryCurve") {}
};
// C++ wrapper for IfcBoundingBox
struct IfcBoundingBox : IfcGeometricRepresentationItem, ObjectHelper<IfcBoundingBox,4> { IfcBoundingBox() : Object("IfcBoundingBox") {}
Lazy< IfcCartesianPoint > Corner;
IfcPositiveLengthMeasure::Out XDim;
IfcPositiveLengthMeasure::Out YDim;
IfcPositiveLengthMeasure::Out ZDim;
};
// C++ wrapper for IfcHalfSpaceSolid
struct IfcHalfSpaceSolid : IfcGeometricRepresentationItem, ObjectHelper<IfcHalfSpaceSolid,2> { IfcHalfSpaceSolid() : Object("IfcHalfSpaceSolid") {}
Lazy< IfcSurface > BaseSurface;
IfcBoolean::Out AgreementFlag;
};
// C++ wrapper for IfcBoxedHalfSpace
struct IfcBoxedHalfSpace : IfcHalfSpaceSolid, ObjectHelper<IfcBoxedHalfSpace,1> { IfcBoxedHalfSpace() : Object("IfcBoxedHalfSpace") {}
Lazy< IfcBoundingBox > Enclosure;
};
// C++ wrapper for IfcSpatialElement
struct IfcSpatialElement : IfcProduct, ObjectHelper<IfcSpatialElement,1> { IfcSpatialElement() : Object("IfcSpatialElement") {}
Maybe< IfcLabel::Out > LongName;
};
// C++ wrapper for IfcSpatialStructureElement
struct IfcSpatialStructureElement : IfcSpatialElement, ObjectHelper<IfcSpatialStructureElement,1> { IfcSpatialStructureElement() : Object("IfcSpatialStructureElement") {}
Maybe< IfcElementCompositionEnum::Out > CompositionType;
};
// C++ wrapper for IfcBuilding
struct IfcBuilding : IfcSpatialStructureElement, ObjectHelper<IfcBuilding,3> { IfcBuilding() : Object("IfcBuilding") {}
Maybe< IfcLengthMeasure::Out > ElevationOfRefHeight;
Maybe< IfcLengthMeasure::Out > ElevationOfTerrain;
Maybe< Lazy< NotImplemented > > BuildingAddress;
};
// C++ wrapper for IfcElementComponent
struct IfcElementComponent : IfcElement, ObjectHelper<IfcElementComponent,0> { IfcElementComponent() : Object("IfcElementComponent") {}
};
// C++ wrapper for IfcBuildingElementPart
struct IfcBuildingElementPart : IfcElementComponent, ObjectHelper<IfcBuildingElementPart,1> { IfcBuildingElementPart() : Object("IfcBuildingElementPart") {}
Maybe< IfcBuildingElementPartTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcElementComponentType
struct IfcElementComponentType : IfcElementType, ObjectHelper<IfcElementComponentType,0> { IfcElementComponentType() : Object("IfcElementComponentType") {}
};
// C++ wrapper for IfcBuildingElementPartType
struct IfcBuildingElementPartType : IfcElementComponentType, ObjectHelper<IfcBuildingElementPartType,1> { IfcBuildingElementPartType() : Object("IfcBuildingElementPartType") {}
IfcBuildingElementPartTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcBuildingElementProxy
struct IfcBuildingElementProxy : IfcBuildingElement, ObjectHelper<IfcBuildingElementProxy,1> { IfcBuildingElementProxy() : Object("IfcBuildingElementProxy") {}
Maybe< IfcBuildingElementProxyTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcBuildingElementProxyType
struct IfcBuildingElementProxyType : IfcBuildingElementType, ObjectHelper<IfcBuildingElementProxyType,1> { IfcBuildingElementProxyType() : Object("IfcBuildingElementProxyType") {}
IfcBuildingElementProxyTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcBuildingStorey
struct IfcBuildingStorey : IfcSpatialStructureElement, ObjectHelper<IfcBuildingStorey,1> { IfcBuildingStorey() : Object("IfcBuildingStorey") {}
Maybe< IfcLengthMeasure::Out > Elevation;
};
// C++ wrapper for IfcSystem
struct IfcSystem : IfcGroup, ObjectHelper<IfcSystem,0> { IfcSystem() : Object("IfcSystem") {}
};
// C++ wrapper for IfcBuildingSystem
struct IfcBuildingSystem : IfcSystem, ObjectHelper<IfcBuildingSystem,2> { IfcBuildingSystem() : Object("IfcBuildingSystem") {}
Maybe< IfcBuildingSystemTypeEnum::Out > PredefinedType;
Maybe< IfcLabel::Out > LongName;
};
// C++ wrapper for IfcBurner
struct IfcBurner : IfcEnergyConversionDevice, ObjectHelper<IfcBurner,1> { IfcBurner() : Object("IfcBurner") {}
Maybe< IfcBurnerTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcBurnerType
struct IfcBurnerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcBurnerType,1> { IfcBurnerType() : Object("IfcBurnerType") {}
IfcBurnerTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcCShapeProfileDef
struct IfcCShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcCShapeProfileDef,5> { IfcCShapeProfileDef() : Object("IfcCShapeProfileDef") {}
IfcPositiveLengthMeasure::Out Depth;
IfcPositiveLengthMeasure::Out Width;
IfcPositiveLengthMeasure::Out WallThickness;
IfcPositiveLengthMeasure::Out Girth;
Maybe< IfcNonNegativeLengthMeasure::Out > InternalFilletRadius;
};
// C++ wrapper for IfcFlowFitting
struct IfcFlowFitting : IfcDistributionFlowElement, ObjectHelper<IfcFlowFitting,0> { IfcFlowFitting() : Object("IfcFlowFitting") {}
};
// C++ wrapper for IfcCableCarrierFitting
struct IfcCableCarrierFitting : IfcFlowFitting, ObjectHelper<IfcCableCarrierFitting,1> { IfcCableCarrierFitting() : Object("IfcCableCarrierFitting") {}
Maybe< IfcCableCarrierFittingTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcFlowFittingType
struct IfcFlowFittingType : IfcDistributionFlowElementType, ObjectHelper<IfcFlowFittingType,0> { IfcFlowFittingType() : Object("IfcFlowFittingType") {}
};
// C++ wrapper for IfcCableCarrierFittingType
struct IfcCableCarrierFittingType : IfcFlowFittingType, ObjectHelper<IfcCableCarrierFittingType,1> { IfcCableCarrierFittingType() : Object("IfcCableCarrierFittingType") {}
IfcCableCarrierFittingTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcFlowSegment
struct IfcFlowSegment : IfcDistributionFlowElement, ObjectHelper<IfcFlowSegment,0> { IfcFlowSegment() : Object("IfcFlowSegment") {}
};
// C++ wrapper for IfcCableCarrierSegment
struct IfcCableCarrierSegment : IfcFlowSegment, ObjectHelper<IfcCableCarrierSegment,1> { IfcCableCarrierSegment() : Object("IfcCableCarrierSegment") {}
Maybe< IfcCableCarrierSegmentTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcFlowSegmentType
struct IfcFlowSegmentType : IfcDistributionFlowElementType, ObjectHelper<IfcFlowSegmentType,0> { IfcFlowSegmentType() : Object("IfcFlowSegmentType") {}
};
// C++ wrapper for IfcCableCarrierSegmentType
struct IfcCableCarrierSegmentType : IfcFlowSegmentType, ObjectHelper<IfcCableCarrierSegmentType,1> { IfcCableCarrierSegmentType() : Object("IfcCableCarrierSegmentType") {}
IfcCableCarrierSegmentTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcCableFitting
struct IfcCableFitting : IfcFlowFitting, ObjectHelper<IfcCableFitting,1> { IfcCableFitting() : Object("IfcCableFitting") {}
Maybe< IfcCableFittingTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcCableFittingType
struct IfcCableFittingType : IfcFlowFittingType, ObjectHelper<IfcCableFittingType,1> { IfcCableFittingType() : Object("IfcCableFittingType") {}
IfcCableFittingTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcCableSegment
struct IfcCableSegment : IfcFlowSegment, ObjectHelper<IfcCableSegment,1> { IfcCableSegment() : Object("IfcCableSegment") {}
Maybe< IfcCableSegmentTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcCableSegmentType
struct IfcCableSegmentType : IfcFlowSegmentType, ObjectHelper<IfcCableSegmentType,1> { IfcCableSegmentType() : Object("IfcCableSegmentType") {}
IfcCableSegmentTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcPoint
struct IfcPoint : IfcGeometricRepresentationItem, ObjectHelper<IfcPoint,0> { IfcPoint() : Object("IfcPoint") {}
};
// C++ wrapper for IfcCartesianPoint
struct IfcCartesianPoint : IfcPoint, ObjectHelper<IfcCartesianPoint,1> { IfcCartesianPoint() : Object("IfcCartesianPoint") {}
ListOf< IfcLengthMeasure, 1, 3 >::Out Coordinates;
};
// C++ wrapper for IfcCartesianPointList
struct IfcCartesianPointList : IfcGeometricRepresentationItem, ObjectHelper<IfcCartesianPointList,0> { IfcCartesianPointList() : Object("IfcCartesianPointList") {}
};
// C++ wrapper for IfcCartesianPointList2D
struct IfcCartesianPointList2D : IfcCartesianPointList, ObjectHelper<IfcCartesianPointList2D,0> { IfcCartesianPointList2D() : Object("IfcCartesianPointList2D") {}
};
// C++ wrapper for IfcCartesianPointList3D
struct IfcCartesianPointList3D : IfcCartesianPointList, ObjectHelper<IfcCartesianPointList3D,0> { IfcCartesianPointList3D() : Object("IfcCartesianPointList3D") {}
};
// C++ wrapper for IfcCartesianTransformationOperator
struct IfcCartesianTransformationOperator : IfcGeometricRepresentationItem, ObjectHelper<IfcCartesianTransformationOperator,4> { IfcCartesianTransformationOperator() : Object("IfcCartesianTransformationOperator") {}
Maybe< Lazy< IfcDirection > > Axis1;
Maybe< Lazy< IfcDirection > > Axis2;
Lazy< IfcCartesianPoint > LocalOrigin;
Maybe< IfcReal::Out > Scale;
};
// C++ wrapper for IfcCartesianTransformationOperator2D
struct IfcCartesianTransformationOperator2D : IfcCartesianTransformationOperator, ObjectHelper<IfcCartesianTransformationOperator2D,0> { IfcCartesianTransformationOperator2D() : Object("IfcCartesianTransformationOperator2D") {}
};
// C++ wrapper for IfcCartesianTransformationOperator2DnonUniform
struct IfcCartesianTransformationOperator2DnonUniform : IfcCartesianTransformationOperator2D, ObjectHelper<IfcCartesianTransformationOperator2DnonUniform,1> { IfcCartesianTransformationOperator2DnonUniform() : Object("IfcCartesianTransformationOperator2DnonUniform") {}
Maybe< IfcReal::Out > Scale2;
};
// C++ wrapper for IfcCartesianTransformationOperator3D
struct IfcCartesianTransformationOperator3D : IfcCartesianTransformationOperator, ObjectHelper<IfcCartesianTransformationOperator3D,1> { IfcCartesianTransformationOperator3D() : Object("IfcCartesianTransformationOperator3D") {}
Maybe< Lazy< IfcDirection > > Axis3;
};
// C++ wrapper for IfcCartesianTransformationOperator3DnonUniform
struct IfcCartesianTransformationOperator3DnonUniform : IfcCartesianTransformationOperator3D, ObjectHelper<IfcCartesianTransformationOperator3DnonUniform,2> { IfcCartesianTransformationOperator3DnonUniform() : Object("IfcCartesianTransformationOperator3DnonUniform") {}
Maybe< IfcReal::Out > Scale2;
Maybe< IfcReal::Out > Scale3;
};
// C++ wrapper for IfcCenterLineProfileDef
struct IfcCenterLineProfileDef : IfcArbitraryOpenProfileDef, ObjectHelper<IfcCenterLineProfileDef,1> { IfcCenterLineProfileDef() : Object("IfcCenterLineProfileDef") {}
IfcPositiveLengthMeasure::Out Thickness;
};
// C++ wrapper for IfcChiller
struct IfcChiller : IfcEnergyConversionDevice, ObjectHelper<IfcChiller,1> { IfcChiller() : Object("IfcChiller") {}
Maybe< IfcChillerTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcChillerType
struct IfcChillerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcChillerType,1> { IfcChillerType() : Object("IfcChillerType") {}
IfcChillerTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcChimney
struct IfcChimney : IfcBuildingElement, ObjectHelper<IfcChimney,1> { IfcChimney() : Object("IfcChimney") {}
Maybe< IfcChimneyTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcChimneyType
struct IfcChimneyType : IfcBuildingElementType, ObjectHelper<IfcChimneyType,1> { IfcChimneyType() : Object("IfcChimneyType") {}
IfcChimneyTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcConic
struct IfcConic : IfcCurve, ObjectHelper<IfcConic,1> { IfcConic() : Object("IfcConic") {}
IfcAxis2Placement::Out Position;
};
// C++ wrapper for IfcCircle
struct IfcCircle : IfcConic, ObjectHelper<IfcCircle,1> { IfcCircle() : Object("IfcCircle") {}
IfcPositiveLengthMeasure::Out Radius;
};
// C++ wrapper for IfcCircleProfileDef
struct IfcCircleProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcCircleProfileDef,1> { IfcCircleProfileDef() : Object("IfcCircleProfileDef") {}
IfcPositiveLengthMeasure::Out Radius;
};
// C++ wrapper for IfcCircleHollowProfileDef
struct IfcCircleHollowProfileDef : IfcCircleProfileDef, ObjectHelper<IfcCircleHollowProfileDef,1> { IfcCircleHollowProfileDef() : Object("IfcCircleHollowProfileDef") {}
IfcPositiveLengthMeasure::Out WallThickness;
};
// C++ wrapper for IfcCivilElement
struct IfcCivilElement : IfcElement, ObjectHelper<IfcCivilElement,0> { IfcCivilElement() : Object("IfcCivilElement") {}
};
// C++ wrapper for IfcCivilElementType
struct IfcCivilElementType : IfcElementType, ObjectHelper<IfcCivilElementType,0> { IfcCivilElementType() : Object("IfcCivilElementType") {}
};
// C++ wrapper for IfcConnectedFaceSet
struct IfcConnectedFaceSet : IfcTopologicalRepresentationItem, ObjectHelper<IfcConnectedFaceSet,1> { IfcConnectedFaceSet() : Object("IfcConnectedFaceSet") {}
ListOf< Lazy< IfcFace >, 1, 0 > CfsFaces;
};
// C++ wrapper for IfcClosedShell
struct IfcClosedShell : IfcConnectedFaceSet, ObjectHelper<IfcClosedShell,0> { IfcClosedShell() : Object("IfcClosedShell") {}
};
// C++ wrapper for IfcCoil
struct IfcCoil : IfcEnergyConversionDevice, ObjectHelper<IfcCoil,1> { IfcCoil() : Object("IfcCoil") {}
Maybe< IfcCoilTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcCoilType
struct IfcCoilType : IfcEnergyConversionDeviceType, ObjectHelper<IfcCoilType,1> { IfcCoilType() : Object("IfcCoilType") {}
IfcCoilTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcColourSpecification
struct IfcColourSpecification : IfcPresentationItem, ObjectHelper<IfcColourSpecification,1> { IfcColourSpecification() : Object("IfcColourSpecification") {}
Maybe< IfcLabel::Out > Name;
};
// C++ wrapper for IfcColourRgb
struct IfcColourRgb : IfcColourSpecification, ObjectHelper<IfcColourRgb,3> { IfcColourRgb() : Object("IfcColourRgb") {}
IfcNormalisedRatioMeasure::Out Red;
IfcNormalisedRatioMeasure::Out Green;
IfcNormalisedRatioMeasure::Out Blue;
};
// C++ wrapper for IfcColumn
struct IfcColumn : IfcBuildingElement, ObjectHelper<IfcColumn,1> { IfcColumn() : Object("IfcColumn") {}
Maybe< IfcColumnTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcColumnStandardCase
struct IfcColumnStandardCase : IfcColumn, ObjectHelper<IfcColumnStandardCase,0> { IfcColumnStandardCase() : Object("IfcColumnStandardCase") {}
};
// C++ wrapper for IfcColumnType
struct IfcColumnType : IfcBuildingElementType, ObjectHelper<IfcColumnType,1> { IfcColumnType() : Object("IfcColumnType") {}
IfcColumnTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcCommunicationsAppliance
struct IfcCommunicationsAppliance : IfcFlowTerminal, ObjectHelper<IfcCommunicationsAppliance,1> { IfcCommunicationsAppliance() : Object("IfcCommunicationsAppliance") {}
Maybe< IfcCommunicationsApplianceTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcCommunicationsApplianceType
struct IfcCommunicationsApplianceType : IfcFlowTerminalType, ObjectHelper<IfcCommunicationsApplianceType,1> { IfcCommunicationsApplianceType() : Object("IfcCommunicationsApplianceType") {}
IfcCommunicationsApplianceTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcPropertyAbstraction
struct IfcPropertyAbstraction : ObjectHelper<IfcPropertyAbstraction,0> { IfcPropertyAbstraction() : Object("IfcPropertyAbstraction") {}
};
// C++ wrapper for IfcProperty
struct IfcProperty : IfcPropertyAbstraction, ObjectHelper<IfcProperty,2> { IfcProperty() : Object("IfcProperty") {}
IfcIdentifier::Out Name;
Maybe< IfcText::Out > Description;
};
// C++ wrapper for IfcComplexProperty
struct IfcComplexProperty : IfcProperty, ObjectHelper<IfcComplexProperty,2> { IfcComplexProperty() : Object("IfcComplexProperty") {}
IfcIdentifier::Out UsageName;
ListOf< Lazy< IfcProperty >, 1, 0 > HasProperties;
};
// C++ wrapper for IfcPropertyDefinition
struct IfcPropertyDefinition : IfcRoot, ObjectHelper<IfcPropertyDefinition,0> { IfcPropertyDefinition() : Object("IfcPropertyDefinition") {}
};
// C++ wrapper for IfcCompositeCurveSegment
struct IfcCompositeCurveSegment : IfcGeometricRepresentationItem, ObjectHelper<IfcCompositeCurveSegment,3> { IfcCompositeCurveSegment() : Object("IfcCompositeCurveSegment") {}
IfcTransitionCode::Out Transition;
IfcBoolean::Out SameSense;
Lazy< IfcCurve > ParentCurve;
};
// C++ wrapper for IfcCompositeProfileDef
struct IfcCompositeProfileDef : IfcProfileDef, ObjectHelper<IfcCompositeProfileDef,2> { IfcCompositeProfileDef() : Object("IfcCompositeProfileDef") {}
ListOf< Lazy< IfcProfileDef >, 2, 0 > Profiles;
Maybe< IfcLabel::Out > Label;
};
// C++ wrapper for IfcFlowMovingDevice
struct IfcFlowMovingDevice : IfcDistributionFlowElement, ObjectHelper<IfcFlowMovingDevice,0> { IfcFlowMovingDevice() : Object("IfcFlowMovingDevice") {}
};
// C++ wrapper for IfcCompressor
struct IfcCompressor : IfcFlowMovingDevice, ObjectHelper<IfcCompressor,1> { IfcCompressor() : Object("IfcCompressor") {}
Maybe< IfcCompressorTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcFlowMovingDeviceType
struct IfcFlowMovingDeviceType : IfcDistributionFlowElementType, ObjectHelper<IfcFlowMovingDeviceType,0> { IfcFlowMovingDeviceType() : Object("IfcFlowMovingDeviceType") {}
};
// C++ wrapper for IfcCompressorType
struct IfcCompressorType : IfcFlowMovingDeviceType, ObjectHelper<IfcCompressorType,1> { IfcCompressorType() : Object("IfcCompressorType") {}
IfcCompressorTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcCondenser
struct IfcCondenser : IfcEnergyConversionDevice, ObjectHelper<IfcCondenser,1> { IfcCondenser() : Object("IfcCondenser") {}
Maybe< IfcCondenserTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcCondenserType
struct IfcCondenserType : IfcEnergyConversionDeviceType, ObjectHelper<IfcCondenserType,1> { IfcCondenserType() : Object("IfcCondenserType") {}
IfcCondenserTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcResource
struct IfcResource : IfcObject, ObjectHelper<IfcResource,2> { IfcResource() : Object("IfcResource") {}
Maybe< IfcIdentifier::Out > Identification;
Maybe< IfcText::Out > LongDescription;
};
// C++ wrapper for IfcConstructionResource
struct IfcConstructionResource : IfcResource, ObjectHelper<IfcConstructionResource,3> { IfcConstructionResource() : Object("IfcConstructionResource") {}
Maybe< Lazy< NotImplemented > > Usage;
Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > BaseCosts;
Maybe< Lazy< NotImplemented > > BaseQuantity;
};
// C++ wrapper for IfcConstructionEquipmentResource
struct IfcConstructionEquipmentResource : IfcConstructionResource, ObjectHelper<IfcConstructionEquipmentResource,1> { IfcConstructionEquipmentResource() : Object("IfcConstructionEquipmentResource") {}
Maybe< IfcConstructionEquipmentResourceTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcTypeResource
struct IfcTypeResource : IfcTypeObject, ObjectHelper<IfcTypeResource,3> { IfcTypeResource() : Object("IfcTypeResource") {}
Maybe< IfcIdentifier::Out > Identification;
Maybe< IfcText::Out > LongDescription;
Maybe< IfcLabel::Out > ResourceType;
};
// C++ wrapper for IfcConstructionResourceType
struct IfcConstructionResourceType : IfcTypeResource, ObjectHelper<IfcConstructionResourceType,2> { IfcConstructionResourceType() : Object("IfcConstructionResourceType") {}
Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > BaseCosts;
Maybe< Lazy< NotImplemented > > BaseQuantity;
};
// C++ wrapper for IfcConstructionEquipmentResourceType
struct IfcConstructionEquipmentResourceType : IfcConstructionResourceType, ObjectHelper<IfcConstructionEquipmentResourceType,1> { IfcConstructionEquipmentResourceType() : Object("IfcConstructionEquipmentResourceType") {}
IfcConstructionEquipmentResourceTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcConstructionMaterialResource
struct IfcConstructionMaterialResource : IfcConstructionResource, ObjectHelper<IfcConstructionMaterialResource,1> { IfcConstructionMaterialResource() : Object("IfcConstructionMaterialResource") {}
Maybe< IfcConstructionMaterialResourceTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcConstructionMaterialResourceType
struct IfcConstructionMaterialResourceType : IfcConstructionResourceType, ObjectHelper<IfcConstructionMaterialResourceType,1> { IfcConstructionMaterialResourceType() : Object("IfcConstructionMaterialResourceType") {}
IfcConstructionMaterialResourceTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcConstructionProductResource
struct IfcConstructionProductResource : IfcConstructionResource, ObjectHelper<IfcConstructionProductResource,1> { IfcConstructionProductResource() : Object("IfcConstructionProductResource") {}
Maybe< IfcConstructionProductResourceTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcConstructionProductResourceType
struct IfcConstructionProductResourceType : IfcConstructionResourceType, ObjectHelper<IfcConstructionProductResourceType,1> { IfcConstructionProductResourceType() : Object("IfcConstructionProductResourceType") {}
IfcConstructionProductResourceTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcContext
struct IfcContext : IfcObjectDefinition, ObjectHelper<IfcContext,5> { IfcContext() : Object("IfcContext") {}
Maybe< IfcLabel::Out > ObjectType;
Maybe< IfcLabel::Out > LongName;
Maybe< IfcLabel::Out > Phase;
Maybe< ListOf< Lazy< IfcRepresentationContext >, 1, 0 > > RepresentationContexts;
Maybe< Lazy< IfcUnitAssignment > > UnitsInContext;
};
// C++ wrapper for IfcNamedUnit
struct IfcNamedUnit : ObjectHelper<IfcNamedUnit,2> { IfcNamedUnit() : Object("IfcNamedUnit") {}
Lazy< NotImplemented > Dimensions;
IfcUnitEnum::Out UnitType;
};
// C++ wrapper for IfcContextDependentUnit
struct IfcContextDependentUnit : IfcNamedUnit, ObjectHelper<IfcContextDependentUnit,1> { IfcContextDependentUnit() : Object("IfcContextDependentUnit") {}
IfcLabel::Out Name;
};
// C++ wrapper for IfcController
struct IfcController : IfcDistributionControlElement, ObjectHelper<IfcController,1> { IfcController() : Object("IfcController") {}
Maybe< IfcControllerTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcControllerType
struct IfcControllerType : IfcDistributionControlElementType, ObjectHelper<IfcControllerType,1> { IfcControllerType() : Object("IfcControllerType") {}
IfcControllerTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcConversionBasedUnit
struct IfcConversionBasedUnit : IfcNamedUnit, ObjectHelper<IfcConversionBasedUnit,2> { IfcConversionBasedUnit() : Object("IfcConversionBasedUnit") {}
IfcLabel::Out Name;
Lazy< IfcMeasureWithUnit > ConversionFactor;
};
// C++ wrapper for IfcConversionBasedUnitWithOffset
struct IfcConversionBasedUnitWithOffset : IfcConversionBasedUnit, ObjectHelper<IfcConversionBasedUnitWithOffset,1> { IfcConversionBasedUnitWithOffset() : Object("IfcConversionBasedUnitWithOffset") {}
IfcReal::Out ConversionOffset;
};
// C++ wrapper for IfcCooledBeam
struct IfcCooledBeam : IfcEnergyConversionDevice, ObjectHelper<IfcCooledBeam,1> { IfcCooledBeam() : Object("IfcCooledBeam") {}
Maybe< IfcCooledBeamTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcCooledBeamType
struct IfcCooledBeamType : IfcEnergyConversionDeviceType, ObjectHelper<IfcCooledBeamType,1> { IfcCooledBeamType() : Object("IfcCooledBeamType") {}
IfcCooledBeamTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcCoolingTower
struct IfcCoolingTower : IfcEnergyConversionDevice, ObjectHelper<IfcCoolingTower,1> { IfcCoolingTower() : Object("IfcCoolingTower") {}
Maybe< IfcCoolingTowerTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcCoolingTowerType
struct IfcCoolingTowerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcCoolingTowerType,1> { IfcCoolingTowerType() : Object("IfcCoolingTowerType") {}
IfcCoolingTowerTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcCostItem
struct IfcCostItem : IfcControl, ObjectHelper<IfcCostItem,3> { IfcCostItem() : Object("IfcCostItem") {}
Maybe< IfcCostItemTypeEnum::Out > PredefinedType;
Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > CostValues;
Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > CostQuantities;
};
// C++ wrapper for IfcCostSchedule
struct IfcCostSchedule : IfcControl, ObjectHelper<IfcCostSchedule,4> { IfcCostSchedule() : Object("IfcCostSchedule") {}
Maybe< IfcCostScheduleTypeEnum::Out > PredefinedType;
Maybe< IfcLabel::Out > Status;
Maybe< IfcDateTime::Out > SubmittedOn;
Maybe< IfcDateTime::Out > UpdateDate;
};
// C++ wrapper for IfcCovering
struct IfcCovering : IfcBuildingElement, ObjectHelper<IfcCovering,1> { IfcCovering() : Object("IfcCovering") {}
Maybe< IfcCoveringTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcCoveringType
struct IfcCoveringType : IfcBuildingElementType, ObjectHelper<IfcCoveringType,1> { IfcCoveringType() : Object("IfcCoveringType") {}
IfcCoveringTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcCrewResource
struct IfcCrewResource : IfcConstructionResource, ObjectHelper<IfcCrewResource,1> { IfcCrewResource() : Object("IfcCrewResource") {}
Maybe< IfcCrewResourceTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcCrewResourceType
struct IfcCrewResourceType : IfcConstructionResourceType, ObjectHelper<IfcCrewResourceType,1> { IfcCrewResourceType() : Object("IfcCrewResourceType") {}
IfcCrewResourceTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcCsgSolid
struct IfcCsgSolid : IfcSolidModel, ObjectHelper<IfcCsgSolid,1> { IfcCsgSolid() : Object("IfcCsgSolid") {}
IfcCsgSelect::Out TreeRootExpression;
};
// C++ wrapper for IfcCurtainWall
struct IfcCurtainWall : IfcBuildingElement, ObjectHelper<IfcCurtainWall,1> { IfcCurtainWall() : Object("IfcCurtainWall") {}
Maybe< IfcCurtainWallTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcCurtainWallType
struct IfcCurtainWallType : IfcBuildingElementType, ObjectHelper<IfcCurtainWallType,1> { IfcCurtainWallType() : Object("IfcCurtainWallType") {}
IfcCurtainWallTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcCurveBoundedPlane
struct IfcCurveBoundedPlane : IfcBoundedSurface, ObjectHelper<IfcCurveBoundedPlane,3> { IfcCurveBoundedPlane() : Object("IfcCurveBoundedPlane") {}
Lazy< IfcPlane > BasisSurface;
Lazy< IfcCurve > OuterBoundary;
ListOf< Lazy< IfcCurve >, 0, 0 > InnerBoundaries;
};
// C++ wrapper for IfcCurveBoundedSurface
struct IfcCurveBoundedSurface : IfcBoundedSurface, ObjectHelper<IfcCurveBoundedSurface,3> { IfcCurveBoundedSurface() : Object("IfcCurveBoundedSurface") {}
Lazy< IfcSurface > BasisSurface;
ListOf< Lazy< IfcBoundaryCurve >, 1, 0 > Boundaries;
IfcBoolean::Out ImplicitOuter;
};
// C++ wrapper for IfcPresentationStyle
struct IfcPresentationStyle : ObjectHelper<IfcPresentationStyle,1> { IfcPresentationStyle() : Object("IfcPresentationStyle") {}
Maybe< IfcLabel::Out > Name;
};
// C++ wrapper for IfcElementarySurface
struct IfcElementarySurface : IfcSurface, ObjectHelper<IfcElementarySurface,1> { IfcElementarySurface() : Object("IfcElementarySurface") {}
Lazy< IfcAxis2Placement3D > Position;
};
// C++ wrapper for IfcCylindricalSurface
struct IfcCylindricalSurface : IfcElementarySurface, ObjectHelper<IfcCylindricalSurface,1> { IfcCylindricalSurface() : Object("IfcCylindricalSurface") {}
IfcPositiveLengthMeasure::Out Radius;
};
// C++ wrapper for IfcDamper
struct IfcDamper : IfcFlowController, ObjectHelper<IfcDamper,1> { IfcDamper() : Object("IfcDamper") {}
Maybe< IfcDamperTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcDamperType
struct IfcDamperType : IfcFlowControllerType, ObjectHelper<IfcDamperType,1> { IfcDamperType() : Object("IfcDamperType") {}
IfcDamperTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcDerivedProfileDef
struct IfcDerivedProfileDef : IfcProfileDef, ObjectHelper<IfcDerivedProfileDef,3> { IfcDerivedProfileDef() : Object("IfcDerivedProfileDef") {}
Lazy< IfcProfileDef > ParentProfile;
Lazy< IfcCartesianTransformationOperator2D > Operator;
Maybe< IfcLabel::Out > Label;
};
// C++ wrapper for IfcDirection
struct IfcDirection : IfcGeometricRepresentationItem, ObjectHelper<IfcDirection,1> { IfcDirection() : Object("IfcDirection") {}
ListOf< IfcReal, 2, 3 >::Out DirectionRatios;
};
// C++ wrapper for IfcDiscreteAccessory
struct IfcDiscreteAccessory : IfcElementComponent, ObjectHelper<IfcDiscreteAccessory,1> { IfcDiscreteAccessory() : Object("IfcDiscreteAccessory") {}
Maybe< IfcDiscreteAccessoryTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcDiscreteAccessoryType
struct IfcDiscreteAccessoryType : IfcElementComponentType, ObjectHelper<IfcDiscreteAccessoryType,1> { IfcDiscreteAccessoryType() : Object("IfcDiscreteAccessoryType") {}
IfcDiscreteAccessoryTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcDistributionChamberElement
struct IfcDistributionChamberElement : IfcDistributionFlowElement, ObjectHelper<IfcDistributionChamberElement,1> { IfcDistributionChamberElement() : Object("IfcDistributionChamberElement") {}
Maybe< IfcDistributionChamberElementTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcDistributionChamberElementType
struct IfcDistributionChamberElementType : IfcDistributionFlowElementType, ObjectHelper<IfcDistributionChamberElementType,1> { IfcDistributionChamberElementType() : Object("IfcDistributionChamberElementType") {}
IfcDistributionChamberElementTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcDistributionSystem
struct IfcDistributionSystem : IfcSystem, ObjectHelper<IfcDistributionSystem,2> { IfcDistributionSystem() : Object("IfcDistributionSystem") {}
Maybe< IfcLabel::Out > LongName;
Maybe< IfcDistributionSystemEnum::Out > PredefinedType;
};
// C++ wrapper for IfcDistributionCircuit
struct IfcDistributionCircuit : IfcDistributionSystem, ObjectHelper<IfcDistributionCircuit,0> { IfcDistributionCircuit() : Object("IfcDistributionCircuit") {}
};
// C++ wrapper for IfcPort
struct IfcPort : IfcProduct, ObjectHelper<IfcPort,0> { IfcPort() : Object("IfcPort") {}
};
// C++ wrapper for IfcDistributionPort
struct IfcDistributionPort : IfcPort, ObjectHelper<IfcDistributionPort,3> { IfcDistributionPort() : Object("IfcDistributionPort") {}
Maybe< IfcFlowDirectionEnum::Out > FlowDirection;
Maybe< IfcDistributionPortTypeEnum::Out > PredefinedType;
Maybe< IfcDistributionSystemEnum::Out > SystemType;
};
// C++ wrapper for IfcDoor
struct IfcDoor : IfcBuildingElement, ObjectHelper<IfcDoor,5> { IfcDoor() : Object("IfcDoor") {}
Maybe< IfcPositiveLengthMeasure::Out > OverallHeight;
Maybe< IfcPositiveLengthMeasure::Out > OverallWidth;
Maybe< IfcDoorTypeEnum::Out > PredefinedType;
Maybe< IfcDoorTypeOperationEnum::Out > OperationType;
Maybe< IfcLabel::Out > UserDefinedOperationType;
};
// C++ wrapper for IfcPropertySetDefinition
struct IfcPropertySetDefinition : IfcPropertyDefinition, ObjectHelper<IfcPropertySetDefinition,0> { IfcPropertySetDefinition() : Object("IfcPropertySetDefinition") {}
};
// C++ wrapper for IfcDoorStandardCase
struct IfcDoorStandardCase : IfcDoor, ObjectHelper<IfcDoorStandardCase,0> { IfcDoorStandardCase() : Object("IfcDoorStandardCase") {}
};
// C++ wrapper for IfcDoorStyle
struct IfcDoorStyle : IfcTypeProduct, ObjectHelper<IfcDoorStyle,4> { IfcDoorStyle() : Object("IfcDoorStyle") {}
IfcDoorStyleOperationEnum::Out OperationType;
IfcDoorStyleConstructionEnum::Out ConstructionType;
IfcBoolean::Out ParameterTakesPrecedence;
IfcBoolean::Out Sizeable;
};
// C++ wrapper for IfcDoorType
struct IfcDoorType : IfcBuildingElementType, ObjectHelper<IfcDoorType,4> { IfcDoorType() : Object("IfcDoorType") {}
IfcDoorTypeEnum::Out PredefinedType;
IfcDoorTypeOperationEnum::Out OperationType;
Maybe< IfcBoolean::Out > ParameterTakesPrecedence;
Maybe< IfcLabel::Out > UserDefinedOperationType;
};
// C++ wrapper for IfcDuctFitting
struct IfcDuctFitting : IfcFlowFitting, ObjectHelper<IfcDuctFitting,1> { IfcDuctFitting() : Object("IfcDuctFitting") {}
Maybe< IfcDuctFittingTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcDuctFittingType
struct IfcDuctFittingType : IfcFlowFittingType, ObjectHelper<IfcDuctFittingType,1> { IfcDuctFittingType() : Object("IfcDuctFittingType") {}
IfcDuctFittingTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcDuctSegment
struct IfcDuctSegment : IfcFlowSegment, ObjectHelper<IfcDuctSegment,1> { IfcDuctSegment() : Object("IfcDuctSegment") {}
Maybe< IfcDuctSegmentTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcDuctSegmentType
struct IfcDuctSegmentType : IfcFlowSegmentType, ObjectHelper<IfcDuctSegmentType,1> { IfcDuctSegmentType() : Object("IfcDuctSegmentType") {}
IfcDuctSegmentTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcFlowTreatmentDevice
struct IfcFlowTreatmentDevice : IfcDistributionFlowElement, ObjectHelper<IfcFlowTreatmentDevice,0> { IfcFlowTreatmentDevice() : Object("IfcFlowTreatmentDevice") {}
};
// C++ wrapper for IfcDuctSilencer
struct IfcDuctSilencer : IfcFlowTreatmentDevice, ObjectHelper<IfcDuctSilencer,1> { IfcDuctSilencer() : Object("IfcDuctSilencer") {}
Maybe< IfcDuctSilencerTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcFlowTreatmentDeviceType
struct IfcFlowTreatmentDeviceType : IfcDistributionFlowElementType, ObjectHelper<IfcFlowTreatmentDeviceType,0> { IfcFlowTreatmentDeviceType() : Object("IfcFlowTreatmentDeviceType") {}
};
// C++ wrapper for IfcDuctSilencerType
struct IfcDuctSilencerType : IfcFlowTreatmentDeviceType, ObjectHelper<IfcDuctSilencerType,1> { IfcDuctSilencerType() : Object("IfcDuctSilencerType") {}
IfcDuctSilencerTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcEdge
struct IfcEdge : IfcTopologicalRepresentationItem, ObjectHelper<IfcEdge,2> { IfcEdge() : Object("IfcEdge") {}
Lazy< IfcVertex > EdgeStart;
Lazy< IfcVertex > EdgeEnd;
};
// C++ wrapper for IfcEdgeCurve
struct IfcEdgeCurve : IfcEdge, ObjectHelper<IfcEdgeCurve,2> { IfcEdgeCurve() : Object("IfcEdgeCurve") {}
Lazy< IfcCurve > EdgeGeometry;
IfcBoolean::Out SameSense;
};
// C++ wrapper for IfcLoop
struct IfcLoop : IfcTopologicalRepresentationItem, ObjectHelper<IfcLoop,0> { IfcLoop() : Object("IfcLoop") {}
};
// C++ wrapper for IfcEdgeLoop
struct IfcEdgeLoop : IfcLoop, ObjectHelper<IfcEdgeLoop,1> { IfcEdgeLoop() : Object("IfcEdgeLoop") {}
ListOf< Lazy< IfcOrientedEdge >, 1, 0 > EdgeList;
};
// C++ wrapper for IfcElectricAppliance
struct IfcElectricAppliance : IfcFlowTerminal, ObjectHelper<IfcElectricAppliance,1> { IfcElectricAppliance() : Object("IfcElectricAppliance") {}
Maybe< IfcElectricApplianceTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcElectricApplianceType
struct IfcElectricApplianceType : IfcFlowTerminalType, ObjectHelper<IfcElectricApplianceType,1> { IfcElectricApplianceType() : Object("IfcElectricApplianceType") {}
IfcElectricApplianceTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcElectricDistributionBoard
struct IfcElectricDistributionBoard : IfcFlowController, ObjectHelper<IfcElectricDistributionBoard,1> { IfcElectricDistributionBoard() : Object("IfcElectricDistributionBoard") {}
Maybe< IfcElectricDistributionBoardTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcElectricDistributionBoardType
struct IfcElectricDistributionBoardType : IfcFlowControllerType, ObjectHelper<IfcElectricDistributionBoardType,1> { IfcElectricDistributionBoardType() : Object("IfcElectricDistributionBoardType") {}
IfcElectricDistributionBoardTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcFlowStorageDevice
struct IfcFlowStorageDevice : IfcDistributionFlowElement, ObjectHelper<IfcFlowStorageDevice,0> { IfcFlowStorageDevice() : Object("IfcFlowStorageDevice") {}
};
// C++ wrapper for IfcElectricFlowStorageDevice
struct IfcElectricFlowStorageDevice : IfcFlowStorageDevice, ObjectHelper<IfcElectricFlowStorageDevice,1> { IfcElectricFlowStorageDevice() : Object("IfcElectricFlowStorageDevice") {}
Maybe< IfcElectricFlowStorageDeviceTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcFlowStorageDeviceType
struct IfcFlowStorageDeviceType : IfcDistributionFlowElementType, ObjectHelper<IfcFlowStorageDeviceType,0> { IfcFlowStorageDeviceType() : Object("IfcFlowStorageDeviceType") {}
};
// C++ wrapper for IfcElectricFlowStorageDeviceType
struct IfcElectricFlowStorageDeviceType : IfcFlowStorageDeviceType, ObjectHelper<IfcElectricFlowStorageDeviceType,1> { IfcElectricFlowStorageDeviceType() : Object("IfcElectricFlowStorageDeviceType") {}
IfcElectricFlowStorageDeviceTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcElectricGenerator
struct IfcElectricGenerator : IfcEnergyConversionDevice, ObjectHelper<IfcElectricGenerator,1> { IfcElectricGenerator() : Object("IfcElectricGenerator") {}
Maybe< IfcElectricGeneratorTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcElectricGeneratorType
struct IfcElectricGeneratorType : IfcEnergyConversionDeviceType, ObjectHelper<IfcElectricGeneratorType,1> { IfcElectricGeneratorType() : Object("IfcElectricGeneratorType") {}
IfcElectricGeneratorTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcElectricMotor
struct IfcElectricMotor : IfcEnergyConversionDevice, ObjectHelper<IfcElectricMotor,1> { IfcElectricMotor() : Object("IfcElectricMotor") {}
Maybe< IfcElectricMotorTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcElectricMotorType
struct IfcElectricMotorType : IfcEnergyConversionDeviceType, ObjectHelper<IfcElectricMotorType,1> { IfcElectricMotorType() : Object("IfcElectricMotorType") {}
IfcElectricMotorTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcElectricTimeControl
struct IfcElectricTimeControl : IfcFlowController, ObjectHelper<IfcElectricTimeControl,1> { IfcElectricTimeControl() : Object("IfcElectricTimeControl") {}
Maybe< IfcElectricTimeControlTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcElectricTimeControlType
struct IfcElectricTimeControlType : IfcFlowControllerType, ObjectHelper<IfcElectricTimeControlType,1> { IfcElectricTimeControlType() : Object("IfcElectricTimeControlType") {}
IfcElectricTimeControlTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcElementAssembly
struct IfcElementAssembly : IfcElement, ObjectHelper<IfcElementAssembly,2> { IfcElementAssembly() : Object("IfcElementAssembly") {}
Maybe< IfcAssemblyPlaceEnum::Out > AssemblyPlace;
Maybe< IfcElementAssemblyTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcElementAssemblyType
struct IfcElementAssemblyType : IfcElementType, ObjectHelper<IfcElementAssemblyType,1> { IfcElementAssemblyType() : Object("IfcElementAssemblyType") {}
IfcElementAssemblyTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcQuantitySet
struct IfcQuantitySet : IfcPropertySetDefinition, ObjectHelper<IfcQuantitySet,0> { IfcQuantitySet() : Object("IfcQuantitySet") {}
};
// C++ wrapper for IfcElementQuantity
struct IfcElementQuantity : IfcQuantitySet, ObjectHelper<IfcElementQuantity,2> { IfcElementQuantity() : Object("IfcElementQuantity") {}
Maybe< IfcLabel::Out > MethodOfMeasurement;
ListOf< Lazy< NotImplemented >, 1, 0 > Quantities;
};
// C++ wrapper for IfcEllipse
struct IfcEllipse : IfcConic, ObjectHelper<IfcEllipse,2> { IfcEllipse() : Object("IfcEllipse") {}
IfcPositiveLengthMeasure::Out SemiAxis1;
IfcPositiveLengthMeasure::Out SemiAxis2;
};
// C++ wrapper for IfcEllipseProfileDef
struct IfcEllipseProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcEllipseProfileDef,2> { IfcEllipseProfileDef() : Object("IfcEllipseProfileDef") {}
IfcPositiveLengthMeasure::Out SemiAxis1;
IfcPositiveLengthMeasure::Out SemiAxis2;
};
// C++ wrapper for IfcEngine
struct IfcEngine : IfcEnergyConversionDevice, ObjectHelper<IfcEngine,1> { IfcEngine() : Object("IfcEngine") {}
Maybe< IfcEngineTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcEngineType
struct IfcEngineType : IfcEnergyConversionDeviceType, ObjectHelper<IfcEngineType,1> { IfcEngineType() : Object("IfcEngineType") {}
IfcEngineTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcEvaporativeCooler
struct IfcEvaporativeCooler : IfcEnergyConversionDevice, ObjectHelper<IfcEvaporativeCooler,1> { IfcEvaporativeCooler() : Object("IfcEvaporativeCooler") {}
Maybe< IfcEvaporativeCoolerTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcEvaporativeCoolerType
struct IfcEvaporativeCoolerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcEvaporativeCoolerType,1> { IfcEvaporativeCoolerType() : Object("IfcEvaporativeCoolerType") {}
IfcEvaporativeCoolerTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcEvaporator
struct IfcEvaporator : IfcEnergyConversionDevice, ObjectHelper<IfcEvaporator,1> { IfcEvaporator() : Object("IfcEvaporator") {}
Maybe< IfcEvaporatorTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcEvaporatorType
struct IfcEvaporatorType : IfcEnergyConversionDeviceType, ObjectHelper<IfcEvaporatorType,1> { IfcEvaporatorType() : Object("IfcEvaporatorType") {}
IfcEvaporatorTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcProcess
struct IfcProcess : IfcObject, ObjectHelper<IfcProcess,2> { IfcProcess() : Object("IfcProcess") {}
Maybe< IfcIdentifier::Out > Identification;
Maybe< IfcText::Out > LongDescription;
};
// C++ wrapper for IfcEvent
struct IfcEvent : IfcProcess, ObjectHelper<IfcEvent,4> { IfcEvent() : Object("IfcEvent") {}
Maybe< IfcEventTypeEnum::Out > PredefinedType;
Maybe< IfcEventTriggerTypeEnum::Out > EventTriggerType;
Maybe< IfcLabel::Out > UserDefinedEventTriggerType;
Maybe< Lazy< NotImplemented > > EventOccurenceTime;
};
// C++ wrapper for IfcTypeProcess
struct IfcTypeProcess : IfcTypeObject, ObjectHelper<IfcTypeProcess,3> { IfcTypeProcess() : Object("IfcTypeProcess") {}
Maybe< IfcIdentifier::Out > Identification;
Maybe< IfcText::Out > LongDescription;
Maybe< IfcLabel::Out > ProcessType;
};
// C++ wrapper for IfcEventType
struct IfcEventType : IfcTypeProcess, ObjectHelper<IfcEventType,3> { IfcEventType() : Object("IfcEventType") {}
IfcEventTypeEnum::Out PredefinedType;
IfcEventTriggerTypeEnum::Out EventTriggerType;
Maybe< IfcLabel::Out > UserDefinedEventTriggerType;
};
// C++ wrapper for IfcExternalSpatialStructureElement
struct IfcExternalSpatialStructureElement : IfcSpatialElement, ObjectHelper<IfcExternalSpatialStructureElement,0> { IfcExternalSpatialStructureElement() : Object("IfcExternalSpatialStructureElement") {}
};
// C++ wrapper for IfcExternalSpatialElement
struct IfcExternalSpatialElement : IfcExternalSpatialStructureElement, ObjectHelper<IfcExternalSpatialElement,1> { IfcExternalSpatialElement() : Object("IfcExternalSpatialElement") {}
Maybe< IfcExternalSpatialElementTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcSweptAreaSolid
struct IfcSweptAreaSolid : IfcSolidModel, ObjectHelper<IfcSweptAreaSolid,2> { IfcSweptAreaSolid() : Object("IfcSweptAreaSolid") {}
Lazy< IfcProfileDef > SweptArea;
Maybe< Lazy< IfcAxis2Placement3D > > Position;
};
// C++ wrapper for IfcExtrudedAreaSolid
struct IfcExtrudedAreaSolid : IfcSweptAreaSolid, ObjectHelper<IfcExtrudedAreaSolid,2> { IfcExtrudedAreaSolid() : Object("IfcExtrudedAreaSolid") {}
Lazy< IfcDirection > ExtrudedDirection;
IfcPositiveLengthMeasure::Out Depth;
};
// C++ wrapper for IfcExtrudedAreaSolidTapered
struct IfcExtrudedAreaSolidTapered : IfcExtrudedAreaSolid, ObjectHelper<IfcExtrudedAreaSolidTapered,1> { IfcExtrudedAreaSolidTapered() : Object("IfcExtrudedAreaSolidTapered") {}
Lazy< IfcProfileDef > EndSweptArea;
};
// C++ wrapper for IfcFaceBasedSurfaceModel
struct IfcFaceBasedSurfaceModel : IfcGeometricRepresentationItem, ObjectHelper<IfcFaceBasedSurfaceModel,1> { IfcFaceBasedSurfaceModel() : Object("IfcFaceBasedSurfaceModel") {}
ListOf< Lazy< IfcConnectedFaceSet >, 1, 0 > FbsmFaces;
};
// C++ wrapper for IfcFaceBound
struct IfcFaceBound : IfcTopologicalRepresentationItem, ObjectHelper<IfcFaceBound,2> { IfcFaceBound() : Object("IfcFaceBound") {}
Lazy< IfcLoop > Bound;
IfcBoolean::Out Orientation;
};
// C++ wrapper for IfcFaceOuterBound
struct IfcFaceOuterBound : IfcFaceBound, ObjectHelper<IfcFaceOuterBound,0> { IfcFaceOuterBound() : Object("IfcFaceOuterBound") {}
};
// C++ wrapper for IfcFacetedBrep
struct IfcFacetedBrep : IfcManifoldSolidBrep, ObjectHelper<IfcFacetedBrep,0> { IfcFacetedBrep() : Object("IfcFacetedBrep") {}
};
// C++ wrapper for IfcFacetedBrepWithVoids
struct IfcFacetedBrepWithVoids : IfcFacetedBrep, ObjectHelper<IfcFacetedBrepWithVoids,1> { IfcFacetedBrepWithVoids() : Object("IfcFacetedBrepWithVoids") {}
ListOf< Lazy< IfcClosedShell >, 1, 0 > Voids;
};
// C++ wrapper for IfcFan
struct IfcFan : IfcFlowMovingDevice, ObjectHelper<IfcFan,1> { IfcFan() : Object("IfcFan") {}
Maybe< IfcFanTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcFanType
struct IfcFanType : IfcFlowMovingDeviceType, ObjectHelper<IfcFanType,1> { IfcFanType() : Object("IfcFanType") {}
IfcFanTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcFastener
struct IfcFastener : IfcElementComponent, ObjectHelper<IfcFastener,1> { IfcFastener() : Object("IfcFastener") {}
Maybe< IfcFastenerTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcFastenerType
struct IfcFastenerType : IfcElementComponentType, ObjectHelper<IfcFastenerType,1> { IfcFastenerType() : Object("IfcFastenerType") {}
IfcFastenerTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcFeatureElement
struct IfcFeatureElement : IfcElement, ObjectHelper<IfcFeatureElement,0> { IfcFeatureElement() : Object("IfcFeatureElement") {}
};
// C++ wrapper for IfcFeatureElementAddition
struct IfcFeatureElementAddition : IfcFeatureElement, ObjectHelper<IfcFeatureElementAddition,0> { IfcFeatureElementAddition() : Object("IfcFeatureElementAddition") {}
};
// C++ wrapper for IfcFeatureElementSubtraction
struct IfcFeatureElementSubtraction : IfcFeatureElement, ObjectHelper<IfcFeatureElementSubtraction,0> { IfcFeatureElementSubtraction() : Object("IfcFeatureElementSubtraction") {}
};
// C++ wrapper for IfcFillAreaStyleHatching
struct IfcFillAreaStyleHatching : IfcGeometricRepresentationItem, ObjectHelper<IfcFillAreaStyleHatching,5> { IfcFillAreaStyleHatching() : Object("IfcFillAreaStyleHatching") {}
Lazy< NotImplemented > HatchLineAppearance;
IfcHatchLineDistanceSelect::Out StartOfNextHatchLine;
Maybe< Lazy< IfcCartesianPoint > > PointOfReferenceHatchLine;
Maybe< Lazy< IfcCartesianPoint > > PatternStart;
IfcPlaneAngleMeasure::Out HatchLineAngle;
};
// C++ wrapper for IfcFillAreaStyleTiles
struct IfcFillAreaStyleTiles : IfcGeometricRepresentationItem, ObjectHelper<IfcFillAreaStyleTiles,3> { IfcFillAreaStyleTiles() : Object("IfcFillAreaStyleTiles") {}
ListOf< Lazy< IfcVector >, 2, 2 > TilingPattern;
ListOf< Lazy< IfcStyledItem >, 1, 0 > Tiles;
IfcPositiveRatioMeasure::Out TilingScale;
};
// C++ wrapper for IfcFilter
struct IfcFilter : IfcFlowTreatmentDevice, ObjectHelper<IfcFilter,1> { IfcFilter() : Object("IfcFilter") {}
Maybe< IfcFilterTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcFilterType
struct IfcFilterType : IfcFlowTreatmentDeviceType, ObjectHelper<IfcFilterType,1> { IfcFilterType() : Object("IfcFilterType") {}
IfcFilterTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcFireSuppressionTerminal
struct IfcFireSuppressionTerminal : IfcFlowTerminal, ObjectHelper<IfcFireSuppressionTerminal,1> { IfcFireSuppressionTerminal() : Object("IfcFireSuppressionTerminal") {}
Maybe< IfcFireSuppressionTerminalTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcFireSuppressionTerminalType
struct IfcFireSuppressionTerminalType : IfcFlowTerminalType, ObjectHelper<IfcFireSuppressionTerminalType,1> { IfcFireSuppressionTerminalType() : Object("IfcFireSuppressionTerminalType") {}
IfcFireSuppressionTerminalTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcFixedReferenceSweptAreaSolid
struct IfcFixedReferenceSweptAreaSolid : IfcSweptAreaSolid, ObjectHelper<IfcFixedReferenceSweptAreaSolid,4> { IfcFixedReferenceSweptAreaSolid() : Object("IfcFixedReferenceSweptAreaSolid") {}
Lazy< IfcCurve > Directrix;
Maybe< IfcParameterValue::Out > StartParam;
Maybe< IfcParameterValue::Out > EndParam;
Lazy< IfcDirection > FixedReference;
};
// C++ wrapper for IfcFlowInstrument
struct IfcFlowInstrument : IfcDistributionControlElement, ObjectHelper<IfcFlowInstrument,1> { IfcFlowInstrument() : Object("IfcFlowInstrument") {}
Maybe< IfcFlowInstrumentTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcFlowInstrumentType
struct IfcFlowInstrumentType : IfcDistributionControlElementType, ObjectHelper<IfcFlowInstrumentType,1> { IfcFlowInstrumentType() : Object("IfcFlowInstrumentType") {}
IfcFlowInstrumentTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcFlowMeter
struct IfcFlowMeter : IfcFlowController, ObjectHelper<IfcFlowMeter,1> { IfcFlowMeter() : Object("IfcFlowMeter") {}
Maybe< IfcFlowMeterTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcFlowMeterType
struct IfcFlowMeterType : IfcFlowControllerType, ObjectHelper<IfcFlowMeterType,1> { IfcFlowMeterType() : Object("IfcFlowMeterType") {}
IfcFlowMeterTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcFooting
struct IfcFooting : IfcBuildingElement, ObjectHelper<IfcFooting,1> { IfcFooting() : Object("IfcFooting") {}
Maybe< IfcFootingTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcFootingType
struct IfcFootingType : IfcBuildingElementType, ObjectHelper<IfcFootingType,1> { IfcFootingType() : Object("IfcFootingType") {}
IfcFootingTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcFurnishingElement
struct IfcFurnishingElement : IfcElement, ObjectHelper<IfcFurnishingElement,0> { IfcFurnishingElement() : Object("IfcFurnishingElement") {}
};
// C++ wrapper for IfcFurnishingElementType
struct IfcFurnishingElementType : IfcElementType, ObjectHelper<IfcFurnishingElementType,0> { IfcFurnishingElementType() : Object("IfcFurnishingElementType") {}
};
// C++ wrapper for IfcFurniture
struct IfcFurniture : IfcFurnishingElement, ObjectHelper<IfcFurniture,1> { IfcFurniture() : Object("IfcFurniture") {}
Maybe< IfcFurnitureTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcFurnitureType
struct IfcFurnitureType : IfcFurnishingElementType, ObjectHelper<IfcFurnitureType,2> { IfcFurnitureType() : Object("IfcFurnitureType") {}
IfcAssemblyPlaceEnum::Out AssemblyPlace;
Maybe< IfcFurnitureTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcGeographicElement
struct IfcGeographicElement : IfcElement, ObjectHelper<IfcGeographicElement,1> { IfcGeographicElement() : Object("IfcGeographicElement") {}
Maybe< IfcGeographicElementTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcGeographicElementType
struct IfcGeographicElementType : IfcElementType, ObjectHelper<IfcGeographicElementType,1> { IfcGeographicElementType() : Object("IfcGeographicElementType") {}
IfcGeographicElementTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcGeometricSet
struct IfcGeometricSet : IfcGeometricRepresentationItem, ObjectHelper<IfcGeometricSet,1> { IfcGeometricSet() : Object("IfcGeometricSet") {}
ListOf< IfcGeometricSetSelect, 1, 0 >::Out Elements;
};
// C++ wrapper for IfcGeometricCurveSet
struct IfcGeometricCurveSet : IfcGeometricSet, ObjectHelper<IfcGeometricCurveSet,0> { IfcGeometricCurveSet() : Object("IfcGeometricCurveSet") {}
};
// C++ wrapper for IfcRepresentationContext
struct IfcRepresentationContext : ObjectHelper<IfcRepresentationContext,2> { IfcRepresentationContext() : Object("IfcRepresentationContext") {}
Maybe< IfcLabel::Out > ContextIdentifier;
Maybe< IfcLabel::Out > ContextType;
};
// C++ wrapper for IfcGeometricRepresentationContext
struct IfcGeometricRepresentationContext : IfcRepresentationContext, ObjectHelper<IfcGeometricRepresentationContext,4> { IfcGeometricRepresentationContext() : Object("IfcGeometricRepresentationContext") {}
IfcDimensionCount::Out CoordinateSpaceDimension;
Maybe< IfcReal::Out > Precision;
IfcAxis2Placement::Out WorldCoordinateSystem;
Maybe< Lazy< IfcDirection > > TrueNorth;
};
// C++ wrapper for IfcGeometricRepresentationSubContext
struct IfcGeometricRepresentationSubContext : IfcGeometricRepresentationContext, ObjectHelper<IfcGeometricRepresentationSubContext,4> { IfcGeometricRepresentationSubContext() : Object("IfcGeometricRepresentationSubContext") {}
Lazy< IfcGeometricRepresentationContext > ParentContext;
Maybe< IfcPositiveRatioMeasure::Out > TargetScale;
IfcGeometricProjectionEnum::Out TargetView;
Maybe< IfcLabel::Out > UserDefinedTargetView;
};
// C++ wrapper for IfcGrid
struct IfcGrid : IfcProduct, ObjectHelper<IfcGrid,4> { IfcGrid() : Object("IfcGrid") {}
ListOf< Lazy< NotImplemented >, 1, 0 > UAxes;
ListOf< Lazy< NotImplemented >, 1, 0 > VAxes;
Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > WAxes;
Maybe< IfcGridTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcObjectPlacement
struct IfcObjectPlacement : ObjectHelper<IfcObjectPlacement,0> { IfcObjectPlacement() : Object("IfcObjectPlacement") {}
};
// C++ wrapper for IfcGridPlacement
struct IfcGridPlacement : IfcObjectPlacement, ObjectHelper<IfcGridPlacement,2> { IfcGridPlacement() : Object("IfcGridPlacement") {}
Lazy< NotImplemented > PlacementLocation;
Maybe< IfcGridPlacementDirectionSelect::Out > PlacementRefDirection;
};
// C++ wrapper for IfcHeatExchanger
struct IfcHeatExchanger : IfcEnergyConversionDevice, ObjectHelper<IfcHeatExchanger,1> { IfcHeatExchanger() : Object("IfcHeatExchanger") {}
Maybe< IfcHeatExchangerTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcHeatExchangerType
struct IfcHeatExchangerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcHeatExchangerType,1> { IfcHeatExchangerType() : Object("IfcHeatExchangerType") {}
IfcHeatExchangerTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcHumidifier
struct IfcHumidifier : IfcEnergyConversionDevice, ObjectHelper<IfcHumidifier,1> { IfcHumidifier() : Object("IfcHumidifier") {}
Maybe< IfcHumidifierTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcHumidifierType
struct IfcHumidifierType : IfcEnergyConversionDeviceType, ObjectHelper<IfcHumidifierType,1> { IfcHumidifierType() : Object("IfcHumidifierType") {}
IfcHumidifierTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcIShapeProfileDef
struct IfcIShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcIShapeProfileDef,7> { IfcIShapeProfileDef() : Object("IfcIShapeProfileDef") {}
IfcPositiveLengthMeasure::Out OverallWidth;
IfcPositiveLengthMeasure::Out OverallDepth;
IfcPositiveLengthMeasure::Out WebThickness;
IfcPositiveLengthMeasure::Out FlangeThickness;
Maybe< IfcNonNegativeLengthMeasure::Out > FilletRadius;
Maybe< IfcNonNegativeLengthMeasure::Out > FlangeEdgeRadius;
Maybe< IfcPlaneAngleMeasure::Out > FlangeSlope;
};
// C++ wrapper for IfcIndexedPolyCurve
struct IfcIndexedPolyCurve : IfcBoundedCurve, ObjectHelper<IfcIndexedPolyCurve,3> { IfcIndexedPolyCurve() : Object("IfcIndexedPolyCurve") {}
Lazy< IfcCartesianPointList > Points;
Maybe< ListOf< IfcSegmentIndexSelect, 1, 0 >::Out > Segments;
Maybe< IfcBoolean::Out > SelfIntersect;
};
// C++ wrapper for IfcTessellatedItem
struct IfcTessellatedItem : IfcGeometricRepresentationItem, ObjectHelper<IfcTessellatedItem,0> { IfcTessellatedItem() : Object("IfcTessellatedItem") {}
};
// C++ wrapper for IfcIndexedPolygonalFace
struct IfcIndexedPolygonalFace : IfcTessellatedItem, ObjectHelper<IfcIndexedPolygonalFace,1> { IfcIndexedPolygonalFace() : Object("IfcIndexedPolygonalFace") {}
ListOf< IfcPositiveInteger, 3, 0 >::Out CoordIndex;
};
// C++ wrapper for IfcIndexedPolygonalFaceWithVoids
struct IfcIndexedPolygonalFaceWithVoids : IfcIndexedPolygonalFace, ObjectHelper<IfcIndexedPolygonalFaceWithVoids,0> { IfcIndexedPolygonalFaceWithVoids() : Object("IfcIndexedPolygonalFaceWithVoids") {}
};
// C++ wrapper for IfcInterceptor
struct IfcInterceptor : IfcFlowTreatmentDevice, ObjectHelper<IfcInterceptor,1> { IfcInterceptor() : Object("IfcInterceptor") {}
Maybe< IfcInterceptorTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcInterceptorType
struct IfcInterceptorType : IfcFlowTreatmentDeviceType, ObjectHelper<IfcInterceptorType,1> { IfcInterceptorType() : Object("IfcInterceptorType") {}
IfcInterceptorTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcSurfaceCurve
struct IfcSurfaceCurve : IfcCurve, ObjectHelper<IfcSurfaceCurve,3> { IfcSurfaceCurve() : Object("IfcSurfaceCurve") {}
Lazy< IfcCurve > Curve3D;
ListOf< Lazy< IfcPcurve >, 1, 2 > AssociatedGeometry;
IfcPreferredSurfaceCurveRepresentation::Out MasterRepresentation;
};
// C++ wrapper for IfcIntersectionCurve
struct IfcIntersectionCurve : IfcSurfaceCurve, ObjectHelper<IfcIntersectionCurve,0> { IfcIntersectionCurve() : Object("IfcIntersectionCurve") {}
};
// C++ wrapper for IfcInventory
struct IfcInventory : IfcGroup, ObjectHelper<IfcInventory,6> { IfcInventory() : Object("IfcInventory") {}
Maybe< IfcInventoryTypeEnum::Out > PredefinedType;
Maybe< IfcActorSelect::Out > Jurisdiction;
Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > ResponsiblePersons;
Maybe< IfcDate::Out > LastUpdateDate;
Maybe< Lazy< NotImplemented > > CurrentValue;
Maybe< Lazy< NotImplemented > > OriginalValue;
};
// C++ wrapper for IfcJunctionBox
struct IfcJunctionBox : IfcFlowFitting, ObjectHelper<IfcJunctionBox,1> { IfcJunctionBox() : Object("IfcJunctionBox") {}
Maybe< IfcJunctionBoxTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcJunctionBoxType
struct IfcJunctionBoxType : IfcFlowFittingType, ObjectHelper<IfcJunctionBoxType,1> { IfcJunctionBoxType() : Object("IfcJunctionBoxType") {}
IfcJunctionBoxTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcLShapeProfileDef
struct IfcLShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcLShapeProfileDef,6> { IfcLShapeProfileDef() : Object("IfcLShapeProfileDef") {}
IfcPositiveLengthMeasure::Out Depth;
Maybe< IfcPositiveLengthMeasure::Out > Width;
IfcPositiveLengthMeasure::Out Thickness;
Maybe< IfcNonNegativeLengthMeasure::Out > FilletRadius;
Maybe< IfcNonNegativeLengthMeasure::Out > EdgeRadius;
Maybe< IfcPlaneAngleMeasure::Out > LegSlope;
};
// C++ wrapper for IfcLaborResource
struct IfcLaborResource : IfcConstructionResource, ObjectHelper<IfcLaborResource,1> { IfcLaborResource() : Object("IfcLaborResource") {}
Maybe< IfcLaborResourceTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcLaborResourceType
struct IfcLaborResourceType : IfcConstructionResourceType, ObjectHelper<IfcLaborResourceType,1> { IfcLaborResourceType() : Object("IfcLaborResourceType") {}
IfcLaborResourceTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcLamp
struct IfcLamp : IfcFlowTerminal, ObjectHelper<IfcLamp,1> { IfcLamp() : Object("IfcLamp") {}
Maybe< IfcLampTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcLampType
struct IfcLampType : IfcFlowTerminalType, ObjectHelper<IfcLampType,1> { IfcLampType() : Object("IfcLampType") {}
IfcLampTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcLightFixture
struct IfcLightFixture : IfcFlowTerminal, ObjectHelper<IfcLightFixture,1> { IfcLightFixture() : Object("IfcLightFixture") {}
Maybe< IfcLightFixtureTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcLightFixtureType
struct IfcLightFixtureType : IfcFlowTerminalType, ObjectHelper<IfcLightFixtureType,1> { IfcLightFixtureType() : Object("IfcLightFixtureType") {}
IfcLightFixtureTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcLightSource
struct IfcLightSource : IfcGeometricRepresentationItem, ObjectHelper<IfcLightSource,4> { IfcLightSource() : Object("IfcLightSource") {}
Maybe< IfcLabel::Out > Name;
Lazy< IfcColourRgb > LightColour;
Maybe< IfcNormalisedRatioMeasure::Out > AmbientIntensity;
Maybe< IfcNormalisedRatioMeasure::Out > Intensity;
};
// C++ wrapper for IfcLightSourceAmbient
struct IfcLightSourceAmbient : IfcLightSource, ObjectHelper<IfcLightSourceAmbient,0> { IfcLightSourceAmbient() : Object("IfcLightSourceAmbient") {}
};
// C++ wrapper for IfcLightSourceDirectional
struct IfcLightSourceDirectional : IfcLightSource, ObjectHelper<IfcLightSourceDirectional,1> { IfcLightSourceDirectional() : Object("IfcLightSourceDirectional") {}
Lazy< IfcDirection > Orientation;
};
// C++ wrapper for IfcLightSourceGoniometric
struct IfcLightSourceGoniometric : IfcLightSource, ObjectHelper<IfcLightSourceGoniometric,6> { IfcLightSourceGoniometric() : Object("IfcLightSourceGoniometric") {}
Lazy< IfcAxis2Placement3D > Position;
Maybe< Lazy< IfcColourRgb > > ColourAppearance;
IfcThermodynamicTemperatureMeasure::Out ColourTemperature;
IfcLuminousFluxMeasure::Out LuminousFlux;
IfcLightEmissionSourceEnum::Out LightEmissionSource;
IfcLightDistributionDataSourceSelect::Out LightDistributionDataSource;
};
// C++ wrapper for IfcLightSourcePositional
struct IfcLightSourcePositional : IfcLightSource, ObjectHelper<IfcLightSourcePositional,5> { IfcLightSourcePositional() : Object("IfcLightSourcePositional") {}
Lazy< IfcCartesianPoint > Position;
IfcPositiveLengthMeasure::Out Radius;
IfcReal::Out ConstantAttenuation;
IfcReal::Out DistanceAttenuation;
IfcReal::Out QuadricAttenuation;
};
// C++ wrapper for IfcLightSourceSpot
struct IfcLightSourceSpot : IfcLightSourcePositional, ObjectHelper<IfcLightSourceSpot,4> { IfcLightSourceSpot() : Object("IfcLightSourceSpot") {}
Lazy< IfcDirection > Orientation;
Maybe< IfcReal::Out > ConcentrationExponent;
IfcPositivePlaneAngleMeasure::Out SpreadAngle;
IfcPositivePlaneAngleMeasure::Out BeamWidthAngle;
};
// C++ wrapper for IfcLine
struct IfcLine : IfcCurve, ObjectHelper<IfcLine,2> { IfcLine() : Object("IfcLine") {}
Lazy< IfcCartesianPoint > Pnt;
Lazy< IfcVector > Dir;
};
// C++ wrapper for IfcLocalPlacement
struct IfcLocalPlacement : IfcObjectPlacement, ObjectHelper<IfcLocalPlacement,2> { IfcLocalPlacement() : Object("IfcLocalPlacement") {}
Maybe< Lazy< IfcObjectPlacement > > PlacementRelTo;
IfcAxis2Placement::Out RelativePlacement;
};
// C++ wrapper for IfcMappedItem
struct IfcMappedItem : IfcRepresentationItem, ObjectHelper<IfcMappedItem,2> { IfcMappedItem() : Object("IfcMappedItem") {}
Lazy< IfcRepresentationMap > MappingSource;
Lazy< IfcCartesianTransformationOperator > MappingTarget;
};
// C++ wrapper for IfcProductRepresentation
struct IfcProductRepresentation : ObjectHelper<IfcProductRepresentation,3> { IfcProductRepresentation() : Object("IfcProductRepresentation") {}
Maybe< IfcLabel::Out > Name;
Maybe< IfcText::Out > Description;
ListOf< Lazy< IfcRepresentation >, 1, 0 > Representations;
};
// C++ wrapper for IfcMaterialDefinitionRepresentation
struct IfcMaterialDefinitionRepresentation : IfcProductRepresentation, ObjectHelper<IfcMaterialDefinitionRepresentation,1> { IfcMaterialDefinitionRepresentation() : Object("IfcMaterialDefinitionRepresentation") {}
Lazy< NotImplemented > RepresentedMaterial;
};
// C++ wrapper for IfcMeasureWithUnit
struct IfcMeasureWithUnit : ObjectHelper<IfcMeasureWithUnit,2> { IfcMeasureWithUnit() : Object("IfcMeasureWithUnit") {}
IfcValue::Out ValueComponent;
IfcUnit::Out UnitComponent;
};
// C++ wrapper for IfcMechanicalFastener
struct IfcMechanicalFastener : IfcElementComponent, ObjectHelper<IfcMechanicalFastener,3> { IfcMechanicalFastener() : Object("IfcMechanicalFastener") {}
Maybe< IfcPositiveLengthMeasure::Out > NominalDiameter;
Maybe< IfcPositiveLengthMeasure::Out > NominalLength;
Maybe< IfcMechanicalFastenerTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcMechanicalFastenerType
struct IfcMechanicalFastenerType : IfcElementComponentType, ObjectHelper<IfcMechanicalFastenerType,3> { IfcMechanicalFastenerType() : Object("IfcMechanicalFastenerType") {}
IfcMechanicalFastenerTypeEnum::Out PredefinedType;
Maybe< IfcPositiveLengthMeasure::Out > NominalDiameter;
Maybe< IfcPositiveLengthMeasure::Out > NominalLength;
};
// C++ wrapper for IfcMedicalDevice
struct IfcMedicalDevice : IfcFlowTerminal, ObjectHelper<IfcMedicalDevice,1> { IfcMedicalDevice() : Object("IfcMedicalDevice") {}
Maybe< IfcMedicalDeviceTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcMedicalDeviceType
struct IfcMedicalDeviceType : IfcFlowTerminalType, ObjectHelper<IfcMedicalDeviceType,1> { IfcMedicalDeviceType() : Object("IfcMedicalDeviceType") {}
IfcMedicalDeviceTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcMember
struct IfcMember : IfcBuildingElement, ObjectHelper<IfcMember,1> { IfcMember() : Object("IfcMember") {}
Maybe< IfcMemberTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcMemberStandardCase
struct IfcMemberStandardCase : IfcMember, ObjectHelper<IfcMemberStandardCase,0> { IfcMemberStandardCase() : Object("IfcMemberStandardCase") {}
};
// C++ wrapper for IfcMemberType
struct IfcMemberType : IfcBuildingElementType, ObjectHelper<IfcMemberType,1> { IfcMemberType() : Object("IfcMemberType") {}
IfcMemberTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcMirroredProfileDef
struct IfcMirroredProfileDef : IfcDerivedProfileDef, ObjectHelper<IfcMirroredProfileDef,0> { IfcMirroredProfileDef() : Object("IfcMirroredProfileDef") {}
};
// C++ wrapper for IfcMotorConnection
struct IfcMotorConnection : IfcEnergyConversionDevice, ObjectHelper<IfcMotorConnection,1> { IfcMotorConnection() : Object("IfcMotorConnection") {}
Maybe< IfcMotorConnectionTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcMotorConnectionType
struct IfcMotorConnectionType : IfcEnergyConversionDeviceType, ObjectHelper<IfcMotorConnectionType,1> { IfcMotorConnectionType() : Object("IfcMotorConnectionType") {}
IfcMotorConnectionTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcOccupant
struct IfcOccupant : IfcActor, ObjectHelper<IfcOccupant,1> { IfcOccupant() : Object("IfcOccupant") {}
Maybe< IfcOccupantTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcOffsetCurve2D
struct IfcOffsetCurve2D : IfcCurve, ObjectHelper<IfcOffsetCurve2D,3> { IfcOffsetCurve2D() : Object("IfcOffsetCurve2D") {}
Lazy< IfcCurve > BasisCurve;
IfcLengthMeasure::Out Distance;
IfcLogical::Out SelfIntersect;
};
// C++ wrapper for IfcOffsetCurve3D
struct IfcOffsetCurve3D : IfcCurve, ObjectHelper<IfcOffsetCurve3D,4> { IfcOffsetCurve3D() : Object("IfcOffsetCurve3D") {}
Lazy< IfcCurve > BasisCurve;
IfcLengthMeasure::Out Distance;
IfcLogical::Out SelfIntersect;
Lazy< IfcDirection > RefDirection;
};
// C++ wrapper for IfcOpenShell
struct IfcOpenShell : IfcConnectedFaceSet, ObjectHelper<IfcOpenShell,0> { IfcOpenShell() : Object("IfcOpenShell") {}
};
// C++ wrapper for IfcOpeningElement
struct IfcOpeningElement : IfcFeatureElementSubtraction, ObjectHelper<IfcOpeningElement,1> { IfcOpeningElement() : Object("IfcOpeningElement") {}
Maybe< IfcOpeningElementTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcOpeningStandardCase
struct IfcOpeningStandardCase : IfcOpeningElement, ObjectHelper<IfcOpeningStandardCase,0> { IfcOpeningStandardCase() : Object("IfcOpeningStandardCase") {}
};
// C++ wrapper for IfcOrientedEdge
struct IfcOrientedEdge : IfcEdge, ObjectHelper<IfcOrientedEdge,2> { IfcOrientedEdge() : Object("IfcOrientedEdge") {}
Lazy< IfcEdge > EdgeElement;
IfcBoolean::Out Orientation;
};
// C++ wrapper for IfcOuterBoundaryCurve
struct IfcOuterBoundaryCurve : IfcBoundaryCurve, ObjectHelper<IfcOuterBoundaryCurve,0> { IfcOuterBoundaryCurve() : Object("IfcOuterBoundaryCurve") {}
};
// C++ wrapper for IfcOutlet
struct IfcOutlet : IfcFlowTerminal, ObjectHelper<IfcOutlet,1> { IfcOutlet() : Object("IfcOutlet") {}
Maybe< IfcOutletTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcOutletType
struct IfcOutletType : IfcFlowTerminalType, ObjectHelper<IfcOutletType,1> { IfcOutletType() : Object("IfcOutletType") {}
IfcOutletTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcPath
struct IfcPath : IfcTopologicalRepresentationItem, ObjectHelper<IfcPath,1> { IfcPath() : Object("IfcPath") {}
ListOf< Lazy< IfcOrientedEdge >, 1, 0 > EdgeList;
};
// C++ wrapper for IfcPcurve
struct IfcPcurve : IfcCurve, ObjectHelper<IfcPcurve,2> { IfcPcurve() : Object("IfcPcurve") {}
Lazy< IfcSurface > BasisSurface;
Lazy< IfcCurve > ReferenceCurve;
};
// C++ wrapper for IfcPerformanceHistory
struct IfcPerformanceHistory : IfcControl, ObjectHelper<IfcPerformanceHistory,2> { IfcPerformanceHistory() : Object("IfcPerformanceHistory") {}
IfcLabel::Out LifeCyclePhase;
Maybe< IfcPerformanceHistoryTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcPermit
struct IfcPermit : IfcControl, ObjectHelper<IfcPermit,3> { IfcPermit() : Object("IfcPermit") {}
Maybe< IfcPermitTypeEnum::Out > PredefinedType;
Maybe< IfcLabel::Out > Status;
Maybe< IfcText::Out > LongDescription;
};
// C++ wrapper for IfcPile
struct IfcPile : IfcBuildingElement, ObjectHelper<IfcPile,2> { IfcPile() : Object("IfcPile") {}
Maybe< IfcPileTypeEnum::Out > PredefinedType;
Maybe< IfcPileConstructionEnum::Out > ConstructionType;
};
// C++ wrapper for IfcPileType
struct IfcPileType : IfcBuildingElementType, ObjectHelper<IfcPileType,1> { IfcPileType() : Object("IfcPileType") {}
IfcPileTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcPipeFitting
struct IfcPipeFitting : IfcFlowFitting, ObjectHelper<IfcPipeFitting,1> { IfcPipeFitting() : Object("IfcPipeFitting") {}
Maybe< IfcPipeFittingTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcPipeFittingType
struct IfcPipeFittingType : IfcFlowFittingType, ObjectHelper<IfcPipeFittingType,1> { IfcPipeFittingType() : Object("IfcPipeFittingType") {}
IfcPipeFittingTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcPipeSegment
struct IfcPipeSegment : IfcFlowSegment, ObjectHelper<IfcPipeSegment,1> { IfcPipeSegment() : Object("IfcPipeSegment") {}
Maybe< IfcPipeSegmentTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcPipeSegmentType
struct IfcPipeSegmentType : IfcFlowSegmentType, ObjectHelper<IfcPipeSegmentType,1> { IfcPipeSegmentType() : Object("IfcPipeSegmentType") {}
IfcPipeSegmentTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcPlanarExtent
struct IfcPlanarExtent : IfcGeometricRepresentationItem, ObjectHelper<IfcPlanarExtent,2> { IfcPlanarExtent() : Object("IfcPlanarExtent") {}
IfcLengthMeasure::Out SizeInX;
IfcLengthMeasure::Out SizeInY;
};
// C++ wrapper for IfcPlanarBox
struct IfcPlanarBox : IfcPlanarExtent, ObjectHelper<IfcPlanarBox,1> { IfcPlanarBox() : Object("IfcPlanarBox") {}
IfcAxis2Placement::Out Placement;
};
// C++ wrapper for IfcPlane
struct IfcPlane : IfcElementarySurface, ObjectHelper<IfcPlane,0> { IfcPlane() : Object("IfcPlane") {}
};
// C++ wrapper for IfcPlate
struct IfcPlate : IfcBuildingElement, ObjectHelper<IfcPlate,1> { IfcPlate() : Object("IfcPlate") {}
Maybe< IfcPlateTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcPlateStandardCase
struct IfcPlateStandardCase : IfcPlate, ObjectHelper<IfcPlateStandardCase,0> { IfcPlateStandardCase() : Object("IfcPlateStandardCase") {}
};
// C++ wrapper for IfcPlateType
struct IfcPlateType : IfcBuildingElementType, ObjectHelper<IfcPlateType,1> { IfcPlateType() : Object("IfcPlateType") {}
IfcPlateTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcPointOnCurve
struct IfcPointOnCurve : IfcPoint, ObjectHelper<IfcPointOnCurve,2> { IfcPointOnCurve() : Object("IfcPointOnCurve") {}
Lazy< IfcCurve > BasisCurve;
IfcParameterValue::Out PointParameter;
};
// C++ wrapper for IfcPointOnSurface
struct IfcPointOnSurface : IfcPoint, ObjectHelper<IfcPointOnSurface,3> { IfcPointOnSurface() : Object("IfcPointOnSurface") {}
Lazy< IfcSurface > BasisSurface;
IfcParameterValue::Out PointParameterU;
IfcParameterValue::Out PointParameterV;
};
// C++ wrapper for IfcPolyLoop
struct IfcPolyLoop : IfcLoop, ObjectHelper<IfcPolyLoop,1> { IfcPolyLoop() : Object("IfcPolyLoop") {}
ListOf< Lazy< IfcCartesianPoint >, 3, 0 > Polygon;
};
// C++ wrapper for IfcPolygonalBoundedHalfSpace
struct IfcPolygonalBoundedHalfSpace : IfcHalfSpaceSolid, ObjectHelper<IfcPolygonalBoundedHalfSpace,2> { IfcPolygonalBoundedHalfSpace() : Object("IfcPolygonalBoundedHalfSpace") {}
Lazy< IfcAxis2Placement3D > Position;
Lazy< IfcBoundedCurve > PolygonalBoundary;
};
// C++ wrapper for IfcTessellatedFaceSet
struct IfcTessellatedFaceSet : IfcTessellatedItem, ObjectHelper<IfcTessellatedFaceSet,1> { IfcTessellatedFaceSet() : Object("IfcTessellatedFaceSet") {}
Lazy< IfcCartesianPointList3D > Coordinates;
};
// C++ wrapper for IfcPolygonalFaceSet
struct IfcPolygonalFaceSet : IfcTessellatedFaceSet, ObjectHelper<IfcPolygonalFaceSet,3> { IfcPolygonalFaceSet() : Object("IfcPolygonalFaceSet") {}
Maybe< IfcBoolean::Out > Closed;
ListOf< Lazy< IfcIndexedPolygonalFace >, 1, 0 > Faces;
Maybe< ListOf< IfcPositiveInteger, 1, 0 >::Out > PnIndex;
};
// C++ wrapper for IfcPolyline
struct IfcPolyline : IfcBoundedCurve, ObjectHelper<IfcPolyline,1> { IfcPolyline() : Object("IfcPolyline") {}
ListOf< Lazy< IfcCartesianPoint >, 2, 0 > Points;
};
// C++ wrapper for IfcPresentationStyleAssignment
struct IfcPresentationStyleAssignment : ObjectHelper<IfcPresentationStyleAssignment,1> { IfcPresentationStyleAssignment() : Object("IfcPresentationStyleAssignment") {}
ListOf< IfcPresentationStyleSelect, 1, 0 >::Out Styles;
};
// C++ wrapper for IfcProcedure
struct IfcProcedure : IfcProcess, ObjectHelper<IfcProcedure,1> { IfcProcedure() : Object("IfcProcedure") {}
Maybe< IfcProcedureTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcProcedureType
struct IfcProcedureType : IfcTypeProcess, ObjectHelper<IfcProcedureType,1> { IfcProcedureType() : Object("IfcProcedureType") {}
IfcProcedureTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcProductDefinitionShape
struct IfcProductDefinitionShape : IfcProductRepresentation, ObjectHelper<IfcProductDefinitionShape,0> { IfcProductDefinitionShape() : Object("IfcProductDefinitionShape") {}
};
// C++ wrapper for IfcProject
struct IfcProject : IfcContext, ObjectHelper<IfcProject,0> { IfcProject() : Object("IfcProject") {}
};
// C++ wrapper for IfcProjectLibrary
struct IfcProjectLibrary : IfcContext, ObjectHelper<IfcProjectLibrary,0> { IfcProjectLibrary() : Object("IfcProjectLibrary") {}
};
// C++ wrapper for IfcProjectOrder
struct IfcProjectOrder : IfcControl, ObjectHelper<IfcProjectOrder,3> { IfcProjectOrder() : Object("IfcProjectOrder") {}
Maybe< IfcProjectOrderTypeEnum::Out > PredefinedType;
Maybe< IfcLabel::Out > Status;
Maybe< IfcText::Out > LongDescription;
};
// C++ wrapper for IfcProjectionElement
struct IfcProjectionElement : IfcFeatureElementAddition, ObjectHelper<IfcProjectionElement,1> { IfcProjectionElement() : Object("IfcProjectionElement") {}
Maybe< IfcProjectionElementTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcSimpleProperty
struct IfcSimpleProperty : IfcProperty, ObjectHelper<IfcSimpleProperty,0> { IfcSimpleProperty() : Object("IfcSimpleProperty") {}
};
// C++ wrapper for IfcPropertyBoundedValue
struct IfcPropertyBoundedValue : IfcSimpleProperty, ObjectHelper<IfcPropertyBoundedValue,4> { IfcPropertyBoundedValue() : Object("IfcPropertyBoundedValue") {}
Maybe< IfcValue::Out > UpperBoundValue;
Maybe< IfcValue::Out > LowerBoundValue;
Maybe< IfcUnit::Out > Unit;
Maybe< IfcValue::Out > SetPointValue;
};
// C++ wrapper for IfcPropertyEnumeratedValue
struct IfcPropertyEnumeratedValue : IfcSimpleProperty, ObjectHelper<IfcPropertyEnumeratedValue,2> { IfcPropertyEnumeratedValue() : Object("IfcPropertyEnumeratedValue") {}
Maybe< ListOf< IfcValue, 1, 0 >::Out > EnumerationValues;
Maybe< Lazy< NotImplemented > > EnumerationReference;
};
// C++ wrapper for IfcPropertyListValue
struct IfcPropertyListValue : IfcSimpleProperty, ObjectHelper<IfcPropertyListValue,2> { IfcPropertyListValue() : Object("IfcPropertyListValue") {}
Maybe< ListOf< IfcValue, 1, 0 >::Out > ListValues;
Maybe< IfcUnit::Out > Unit;
};
// C++ wrapper for IfcPropertyReferenceValue
struct IfcPropertyReferenceValue : IfcSimpleProperty, ObjectHelper<IfcPropertyReferenceValue,2> { IfcPropertyReferenceValue() : Object("IfcPropertyReferenceValue") {}
Maybe< IfcText::Out > UsageName;
Maybe< IfcObjectReferenceSelect::Out > PropertyReference;
};
// C++ wrapper for IfcPropertySet
struct IfcPropertySet : IfcPropertySetDefinition, ObjectHelper<IfcPropertySet,1> { IfcPropertySet() : Object("IfcPropertySet") {}
ListOf< Lazy< IfcProperty >, 1, 0 > HasProperties;
};
// C++ wrapper for IfcPropertySingleValue
struct IfcPropertySingleValue : IfcSimpleProperty, ObjectHelper<IfcPropertySingleValue,2> { IfcPropertySingleValue() : Object("IfcPropertySingleValue") {}
Maybe< IfcValue::Out > NominalValue;
Maybe< IfcUnit::Out > Unit;
};
// C++ wrapper for IfcPropertyTableValue
struct IfcPropertyTableValue : IfcSimpleProperty, ObjectHelper<IfcPropertyTableValue,6> { IfcPropertyTableValue() : Object("IfcPropertyTableValue") {}
Maybe< ListOf< IfcValue, 1, 0 >::Out > DefiningValues;
Maybe< ListOf< IfcValue, 1, 0 >::Out > DefinedValues;
Maybe< IfcText::Out > Expression;
Maybe< IfcUnit::Out > DefiningUnit;
Maybe< IfcUnit::Out > DefinedUnit;
Maybe< IfcCurveInterpolationEnum::Out > CurveInterpolation;
};
// C++ wrapper for IfcProtectiveDevice
struct IfcProtectiveDevice : IfcFlowController, ObjectHelper<IfcProtectiveDevice,1> { IfcProtectiveDevice() : Object("IfcProtectiveDevice") {}
Maybe< IfcProtectiveDeviceTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcProtectiveDeviceTrippingUnit
struct IfcProtectiveDeviceTrippingUnit : IfcDistributionControlElement, ObjectHelper<IfcProtectiveDeviceTrippingUnit,1> { IfcProtectiveDeviceTrippingUnit() : Object("IfcProtectiveDeviceTrippingUnit") {}
Maybe< IfcProtectiveDeviceTrippingUnitTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcProtectiveDeviceTrippingUnitType
struct IfcProtectiveDeviceTrippingUnitType : IfcDistributionControlElementType, ObjectHelper<IfcProtectiveDeviceTrippingUnitType,1> { IfcProtectiveDeviceTrippingUnitType() : Object("IfcProtectiveDeviceTrippingUnitType") {}
IfcProtectiveDeviceTrippingUnitTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcProtectiveDeviceType
struct IfcProtectiveDeviceType : IfcFlowControllerType, ObjectHelper<IfcProtectiveDeviceType,1> { IfcProtectiveDeviceType() : Object("IfcProtectiveDeviceType") {}
IfcProtectiveDeviceTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcProxy
struct IfcProxy : IfcProduct, ObjectHelper<IfcProxy,2> { IfcProxy() : Object("IfcProxy") {}
IfcObjectTypeEnum::Out ProxyType;
Maybe< IfcLabel::Out > Tag;
};
// C++ wrapper for IfcPump
struct IfcPump : IfcFlowMovingDevice, ObjectHelper<IfcPump,1> { IfcPump() : Object("IfcPump") {}
Maybe< IfcPumpTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcPumpType
struct IfcPumpType : IfcFlowMovingDeviceType, ObjectHelper<IfcPumpType,1> { IfcPumpType() : Object("IfcPumpType") {}
IfcPumpTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcRailing
struct IfcRailing : IfcBuildingElement, ObjectHelper<IfcRailing,1> { IfcRailing() : Object("IfcRailing") {}
Maybe< IfcRailingTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcRailingType
struct IfcRailingType : IfcBuildingElementType, ObjectHelper<IfcRailingType,1> { IfcRailingType() : Object("IfcRailingType") {}
IfcRailingTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcRamp
struct IfcRamp : IfcBuildingElement, ObjectHelper<IfcRamp,1> { IfcRamp() : Object("IfcRamp") {}
Maybe< IfcRampTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcRampFlight
struct IfcRampFlight : IfcBuildingElement, ObjectHelper<IfcRampFlight,1> { IfcRampFlight() : Object("IfcRampFlight") {}
Maybe< IfcRampFlightTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcRampFlightType
struct IfcRampFlightType : IfcBuildingElementType, ObjectHelper<IfcRampFlightType,1> { IfcRampFlightType() : Object("IfcRampFlightType") {}
IfcRampFlightTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcRampType
struct IfcRampType : IfcBuildingElementType, ObjectHelper<IfcRampType,1> { IfcRampType() : Object("IfcRampType") {}
IfcRampTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcRationalBSplineCurveWithKnots
struct IfcRationalBSplineCurveWithKnots : IfcBSplineCurveWithKnots, ObjectHelper<IfcRationalBSplineCurveWithKnots,1> { IfcRationalBSplineCurveWithKnots() : Object("IfcRationalBSplineCurveWithKnots") {}
ListOf< IfcReal, 2, 0 >::Out WeightsData;
};
// C++ wrapper for IfcRationalBSplineSurfaceWithKnots
struct IfcRationalBSplineSurfaceWithKnots : IfcBSplineSurfaceWithKnots, ObjectHelper<IfcRationalBSplineSurfaceWithKnots,0> { IfcRationalBSplineSurfaceWithKnots() : Object("IfcRationalBSplineSurfaceWithKnots") {}
};
// C++ wrapper for IfcRectangleProfileDef
struct IfcRectangleProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcRectangleProfileDef,2> { IfcRectangleProfileDef() : Object("IfcRectangleProfileDef") {}
IfcPositiveLengthMeasure::Out XDim;
IfcPositiveLengthMeasure::Out YDim;
};
// C++ wrapper for IfcRectangleHollowProfileDef
struct IfcRectangleHollowProfileDef : IfcRectangleProfileDef, ObjectHelper<IfcRectangleHollowProfileDef,3> { IfcRectangleHollowProfileDef() : Object("IfcRectangleHollowProfileDef") {}
IfcPositiveLengthMeasure::Out WallThickness;
Maybe< IfcNonNegativeLengthMeasure::Out > InnerFilletRadius;
Maybe< IfcNonNegativeLengthMeasure::Out > OuterFilletRadius;
};
// C++ wrapper for IfcRectangularPyramid
struct IfcRectangularPyramid : IfcCsgPrimitive3D, ObjectHelper<IfcRectangularPyramid,3> { IfcRectangularPyramid() : Object("IfcRectangularPyramid") {}
IfcPositiveLengthMeasure::Out XLength;
IfcPositiveLengthMeasure::Out YLength;
IfcPositiveLengthMeasure::Out Height;
};
// C++ wrapper for IfcRectangularTrimmedSurface
struct IfcRectangularTrimmedSurface : IfcBoundedSurface, ObjectHelper<IfcRectangularTrimmedSurface,7> { IfcRectangularTrimmedSurface() : Object("IfcRectangularTrimmedSurface") {}
Lazy< IfcSurface > BasisSurface;
IfcParameterValue::Out U1;
IfcParameterValue::Out V1;
IfcParameterValue::Out U2;
IfcParameterValue::Out V2;
IfcBoolean::Out Usense;
IfcBoolean::Out Vsense;
};
// C++ wrapper for IfcReinforcingElement
struct IfcReinforcingElement : IfcElementComponent, ObjectHelper<IfcReinforcingElement,1> { IfcReinforcingElement() : Object("IfcReinforcingElement") {}
Maybe< IfcLabel::Out > SteelGrade;
};
// C++ wrapper for IfcReinforcingBar
struct IfcReinforcingBar : IfcReinforcingElement, ObjectHelper<IfcReinforcingBar,5> { IfcReinforcingBar() : Object("IfcReinforcingBar") {}
Maybe< IfcPositiveLengthMeasure::Out > NominalDiameter;
Maybe< IfcAreaMeasure::Out > CrossSectionArea;
Maybe< IfcPositiveLengthMeasure::Out > BarLength;
Maybe< IfcReinforcingBarTypeEnum::Out > PredefinedType;
Maybe< IfcReinforcingBarSurfaceEnum::Out > BarSurface;
};
// C++ wrapper for IfcReinforcingElementType
struct IfcReinforcingElementType : IfcElementComponentType, ObjectHelper<IfcReinforcingElementType,0> { IfcReinforcingElementType() : Object("IfcReinforcingElementType") {}
};
// C++ wrapper for IfcReinforcingBarType
struct IfcReinforcingBarType : IfcReinforcingElementType, ObjectHelper<IfcReinforcingBarType,7> { IfcReinforcingBarType() : Object("IfcReinforcingBarType") {}
IfcReinforcingBarTypeEnum::Out PredefinedType;
Maybe< IfcPositiveLengthMeasure::Out > NominalDiameter;
Maybe< IfcAreaMeasure::Out > CrossSectionArea;
Maybe< IfcPositiveLengthMeasure::Out > BarLength;
Maybe< IfcReinforcingBarSurfaceEnum::Out > BarSurface;
Maybe< IfcLabel::Out > BendingShapeCode;
Maybe< ListOf< IfcBendingParameterSelect, 1, 0 >::Out > BendingParameters;
};
// C++ wrapper for IfcReinforcingMesh
struct IfcReinforcingMesh : IfcReinforcingElement, ObjectHelper<IfcReinforcingMesh,9> { IfcReinforcingMesh() : Object("IfcReinforcingMesh") {}
Maybe< IfcPositiveLengthMeasure::Out > MeshLength;
Maybe< IfcPositiveLengthMeasure::Out > MeshWidth;
Maybe< IfcPositiveLengthMeasure::Out > LongitudinalBarNominalDiameter;
Maybe< IfcPositiveLengthMeasure::Out > TransverseBarNominalDiameter;
Maybe< IfcAreaMeasure::Out > LongitudinalBarCrossSectionArea;
Maybe< IfcAreaMeasure::Out > TransverseBarCrossSectionArea;
Maybe< IfcPositiveLengthMeasure::Out > LongitudinalBarSpacing;
Maybe< IfcPositiveLengthMeasure::Out > TransverseBarSpacing;
Maybe< IfcReinforcingMeshTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcReinforcingMeshType
struct IfcReinforcingMeshType : IfcReinforcingElementType, ObjectHelper<IfcReinforcingMeshType,11> { IfcReinforcingMeshType() : Object("IfcReinforcingMeshType") {}
IfcReinforcingMeshTypeEnum::Out PredefinedType;
Maybe< IfcPositiveLengthMeasure::Out > MeshLength;
Maybe< IfcPositiveLengthMeasure::Out > MeshWidth;
Maybe< IfcPositiveLengthMeasure::Out > LongitudinalBarNominalDiameter;
Maybe< IfcPositiveLengthMeasure::Out > TransverseBarNominalDiameter;
Maybe< IfcAreaMeasure::Out > LongitudinalBarCrossSectionArea;
Maybe< IfcAreaMeasure::Out > TransverseBarCrossSectionArea;
Maybe< IfcPositiveLengthMeasure::Out > LongitudinalBarSpacing;
Maybe< IfcPositiveLengthMeasure::Out > TransverseBarSpacing;
Maybe< IfcLabel::Out > BendingShapeCode;
Maybe< ListOf< IfcBendingParameterSelect, 1, 0 >::Out > BendingParameters;
};
// C++ wrapper for IfcRelationship
struct IfcRelationship : IfcRoot, ObjectHelper<IfcRelationship,0> { IfcRelationship() : Object("IfcRelationship") {}
};
// C++ wrapper for IfcRelDecomposes
struct IfcRelDecomposes : IfcRelationship, ObjectHelper<IfcRelDecomposes,0> { IfcRelDecomposes() : Object("IfcRelDecomposes") {}
};
// C++ wrapper for IfcRelAggregates
struct IfcRelAggregates : IfcRelDecomposes, ObjectHelper<IfcRelAggregates,2> { IfcRelAggregates() : Object("IfcRelAggregates") {}
Lazy< IfcObjectDefinition > RelatingObject;
ListOf< Lazy< IfcObjectDefinition >, 1, 0 > RelatedObjects;
};
// C++ wrapper for IfcRelConnects
struct IfcRelConnects : IfcRelationship, ObjectHelper<IfcRelConnects,0> { IfcRelConnects() : Object("IfcRelConnects") {}
};
// C++ wrapper for IfcRelContainedInSpatialStructure
struct IfcRelContainedInSpatialStructure : IfcRelConnects, ObjectHelper<IfcRelContainedInSpatialStructure,2> { IfcRelContainedInSpatialStructure() : Object("IfcRelContainedInSpatialStructure") {}
ListOf< Lazy< IfcProduct >, 1, 0 > RelatedElements;
Lazy< IfcSpatialElement > RelatingStructure;
};
// C++ wrapper for IfcRelDefines
struct IfcRelDefines : IfcRelationship, ObjectHelper<IfcRelDefines,0> { IfcRelDefines() : Object("IfcRelDefines") {}
};
// C++ wrapper for IfcRelDefinesByProperties
struct IfcRelDefinesByProperties : IfcRelDefines, ObjectHelper<IfcRelDefinesByProperties,2> { IfcRelDefinesByProperties() : Object("IfcRelDefinesByProperties") {}
ListOf< Lazy< IfcObjectDefinition >, 1, 0 > RelatedObjects;
IfcPropertySetDefinitionSelect::Out RelatingPropertyDefinition;
};
// C++ wrapper for IfcRelFillsElement
struct IfcRelFillsElement : IfcRelConnects, ObjectHelper<IfcRelFillsElement,2> { IfcRelFillsElement() : Object("IfcRelFillsElement") {}
Lazy< IfcOpeningElement > RelatingOpeningElement;
Lazy< IfcElement > RelatedBuildingElement;
};
// C++ wrapper for IfcRelVoidsElement
struct IfcRelVoidsElement : IfcRelDecomposes, ObjectHelper<IfcRelVoidsElement,2> { IfcRelVoidsElement() : Object("IfcRelVoidsElement") {}
Lazy< IfcElement > RelatingBuildingElement;
Lazy< IfcFeatureElementSubtraction > RelatedOpeningElement;
};
// C++ wrapper for IfcReparametrisedCompositeCurveSegment
struct IfcReparametrisedCompositeCurveSegment : IfcCompositeCurveSegment, ObjectHelper<IfcReparametrisedCompositeCurveSegment,1> { IfcReparametrisedCompositeCurveSegment() : Object("IfcReparametrisedCompositeCurveSegment") {}
IfcParameterValue::Out ParamLength;
};
// C++ wrapper for IfcRepresentation
struct IfcRepresentation : ObjectHelper<IfcRepresentation,4> { IfcRepresentation() : Object("IfcRepresentation") {}
Lazy< IfcRepresentationContext > ContextOfItems;
Maybe< IfcLabel::Out > RepresentationIdentifier;
Maybe< IfcLabel::Out > RepresentationType;
ListOf< Lazy< IfcRepresentationItem >, 1, 0 > Items;
};
// C++ wrapper for IfcRepresentationMap
struct IfcRepresentationMap : ObjectHelper<IfcRepresentationMap,2> { IfcRepresentationMap() : Object("IfcRepresentationMap") {}
IfcAxis2Placement::Out MappingOrigin;
Lazy< IfcRepresentation > MappedRepresentation;
};
// C++ wrapper for IfcRevolvedAreaSolid
struct IfcRevolvedAreaSolid : IfcSweptAreaSolid, ObjectHelper<IfcRevolvedAreaSolid,2> { IfcRevolvedAreaSolid() : Object("IfcRevolvedAreaSolid") {}
Lazy< IfcAxis1Placement > Axis;
IfcPlaneAngleMeasure::Out Angle;
};
// C++ wrapper for IfcRevolvedAreaSolidTapered
struct IfcRevolvedAreaSolidTapered : IfcRevolvedAreaSolid, ObjectHelper<IfcRevolvedAreaSolidTapered,1> { IfcRevolvedAreaSolidTapered() : Object("IfcRevolvedAreaSolidTapered") {}
Lazy< IfcProfileDef > EndSweptArea;
};
// C++ wrapper for IfcRightCircularCone
struct IfcRightCircularCone : IfcCsgPrimitive3D, ObjectHelper<IfcRightCircularCone,2> { IfcRightCircularCone() : Object("IfcRightCircularCone") {}
IfcPositiveLengthMeasure::Out Height;
IfcPositiveLengthMeasure::Out BottomRadius;
};
// C++ wrapper for IfcRightCircularCylinder
struct IfcRightCircularCylinder : IfcCsgPrimitive3D, ObjectHelper<IfcRightCircularCylinder,2> { IfcRightCircularCylinder() : Object("IfcRightCircularCylinder") {}
IfcPositiveLengthMeasure::Out Height;
IfcPositiveLengthMeasure::Out Radius;
};
// C++ wrapper for IfcRoof
struct IfcRoof : IfcBuildingElement, ObjectHelper<IfcRoof,1> { IfcRoof() : Object("IfcRoof") {}
Maybe< IfcRoofTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcRoofType
struct IfcRoofType : IfcBuildingElementType, ObjectHelper<IfcRoofType,1> { IfcRoofType() : Object("IfcRoofType") {}
IfcRoofTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcRoundedRectangleProfileDef
struct IfcRoundedRectangleProfileDef : IfcRectangleProfileDef, ObjectHelper<IfcRoundedRectangleProfileDef,1> { IfcRoundedRectangleProfileDef() : Object("IfcRoundedRectangleProfileDef") {}
IfcPositiveLengthMeasure::Out RoundingRadius;
};
// C++ wrapper for IfcSIUnit
struct IfcSIUnit : IfcNamedUnit, ObjectHelper<IfcSIUnit,2> { IfcSIUnit() : Object("IfcSIUnit") {}
Maybe< IfcSIPrefix::Out > Prefix;
IfcSIUnitName::Out Name;
};
// C++ wrapper for IfcSanitaryTerminal
struct IfcSanitaryTerminal : IfcFlowTerminal, ObjectHelper<IfcSanitaryTerminal,1> { IfcSanitaryTerminal() : Object("IfcSanitaryTerminal") {}
Maybe< IfcSanitaryTerminalTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcSanitaryTerminalType
struct IfcSanitaryTerminalType : IfcFlowTerminalType, ObjectHelper<IfcSanitaryTerminalType,1> { IfcSanitaryTerminalType() : Object("IfcSanitaryTerminalType") {}
IfcSanitaryTerminalTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcSeamCurve
struct IfcSeamCurve : IfcSurfaceCurve, ObjectHelper<IfcSeamCurve,0> { IfcSeamCurve() : Object("IfcSeamCurve") {}
};
// C++ wrapper for IfcSectionedSpine
struct IfcSectionedSpine : IfcGeometricRepresentationItem, ObjectHelper<IfcSectionedSpine,3> { IfcSectionedSpine() : Object("IfcSectionedSpine") {}
Lazy< IfcCompositeCurve > SpineCurve;
ListOf< Lazy< IfcProfileDef >, 2, 0 > CrossSections;
ListOf< Lazy< IfcAxis2Placement3D >, 2, 0 > CrossSectionPositions;
};
// C++ wrapper for IfcSensor
struct IfcSensor : IfcDistributionControlElement, ObjectHelper<IfcSensor,1> { IfcSensor() : Object("IfcSensor") {}
Maybe< IfcSensorTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcSensorType
struct IfcSensorType : IfcDistributionControlElementType, ObjectHelper<IfcSensorType,1> { IfcSensorType() : Object("IfcSensorType") {}
IfcSensorTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcShadingDevice
struct IfcShadingDevice : IfcBuildingElement, ObjectHelper<IfcShadingDevice,1> { IfcShadingDevice() : Object("IfcShadingDevice") {}
Maybe< IfcShadingDeviceTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcShadingDeviceType
struct IfcShadingDeviceType : IfcBuildingElementType, ObjectHelper<IfcShadingDeviceType,1> { IfcShadingDeviceType() : Object("IfcShadingDeviceType") {}
IfcShadingDeviceTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcShapeModel
struct IfcShapeModel : IfcRepresentation, ObjectHelper<IfcShapeModel,0> { IfcShapeModel() : Object("IfcShapeModel") {}
};
// C++ wrapper for IfcShapeRepresentation
struct IfcShapeRepresentation : IfcShapeModel, ObjectHelper<IfcShapeRepresentation,0> { IfcShapeRepresentation() : Object("IfcShapeRepresentation") {}
};
// C++ wrapper for IfcShellBasedSurfaceModel
struct IfcShellBasedSurfaceModel : IfcGeometricRepresentationItem, ObjectHelper<IfcShellBasedSurfaceModel,1> { IfcShellBasedSurfaceModel() : Object("IfcShellBasedSurfaceModel") {}
ListOf< IfcShell, 1, 0 >::Out SbsmBoundary;
};
// C++ wrapper for IfcSite
struct IfcSite : IfcSpatialStructureElement, ObjectHelper<IfcSite,5> { IfcSite() : Object("IfcSite") {}
Maybe< IfcCompoundPlaneAngleMeasure::Out > RefLatitude;
Maybe< IfcCompoundPlaneAngleMeasure::Out > RefLongitude;
Maybe< IfcLengthMeasure::Out > RefElevation;
Maybe< IfcLabel::Out > LandTitleNumber;
Maybe< Lazy< NotImplemented > > SiteAddress;
};
// C++ wrapper for IfcSlab
struct IfcSlab : IfcBuildingElement, ObjectHelper<IfcSlab,1> { IfcSlab() : Object("IfcSlab") {}
Maybe< IfcSlabTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcSlabElementedCase
struct IfcSlabElementedCase : IfcSlab, ObjectHelper<IfcSlabElementedCase,0> { IfcSlabElementedCase() : Object("IfcSlabElementedCase") {}
};
// C++ wrapper for IfcSlabStandardCase
struct IfcSlabStandardCase : IfcSlab, ObjectHelper<IfcSlabStandardCase,0> { IfcSlabStandardCase() : Object("IfcSlabStandardCase") {}
};
// C++ wrapper for IfcSlabType
struct IfcSlabType : IfcBuildingElementType, ObjectHelper<IfcSlabType,1> { IfcSlabType() : Object("IfcSlabType") {}
IfcSlabTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcSolarDevice
struct IfcSolarDevice : IfcEnergyConversionDevice, ObjectHelper<IfcSolarDevice,1> { IfcSolarDevice() : Object("IfcSolarDevice") {}
Maybe< IfcSolarDeviceTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcSolarDeviceType
struct IfcSolarDeviceType : IfcEnergyConversionDeviceType, ObjectHelper<IfcSolarDeviceType,1> { IfcSolarDeviceType() : Object("IfcSolarDeviceType") {}
IfcSolarDeviceTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcSpace
struct IfcSpace : IfcSpatialStructureElement, ObjectHelper<IfcSpace,2> { IfcSpace() : Object("IfcSpace") {}
Maybe< IfcSpaceTypeEnum::Out > PredefinedType;
Maybe< IfcLengthMeasure::Out > ElevationWithFlooring;
};
// C++ wrapper for IfcSpaceHeater
struct IfcSpaceHeater : IfcFlowTerminal, ObjectHelper<IfcSpaceHeater,1> { IfcSpaceHeater() : Object("IfcSpaceHeater") {}
Maybe< IfcSpaceHeaterTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcSpaceHeaterType
struct IfcSpaceHeaterType : IfcFlowTerminalType, ObjectHelper<IfcSpaceHeaterType,1> { IfcSpaceHeaterType() : Object("IfcSpaceHeaterType") {}
IfcSpaceHeaterTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcSpatialElementType
struct IfcSpatialElementType : IfcTypeProduct, ObjectHelper<IfcSpatialElementType,1> { IfcSpatialElementType() : Object("IfcSpatialElementType") {}
Maybe< IfcLabel::Out > ElementType;
};
// C++ wrapper for IfcSpatialStructureElementType
struct IfcSpatialStructureElementType : IfcSpatialElementType, ObjectHelper<IfcSpatialStructureElementType,0> { IfcSpatialStructureElementType() : Object("IfcSpatialStructureElementType") {}
};
// C++ wrapper for IfcSpaceType
struct IfcSpaceType : IfcSpatialStructureElementType, ObjectHelper<IfcSpaceType,2> { IfcSpaceType() : Object("IfcSpaceType") {}
IfcSpaceTypeEnum::Out PredefinedType;
Maybe< IfcLabel::Out > LongName;
};
// C++ wrapper for IfcSpatialZone
struct IfcSpatialZone : IfcSpatialElement, ObjectHelper<IfcSpatialZone,1> { IfcSpatialZone() : Object("IfcSpatialZone") {}
Maybe< IfcSpatialZoneTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcSpatialZoneType
struct IfcSpatialZoneType : IfcSpatialElementType, ObjectHelper<IfcSpatialZoneType,2> { IfcSpatialZoneType() : Object("IfcSpatialZoneType") {}
IfcSpatialZoneTypeEnum::Out PredefinedType;
Maybe< IfcLabel::Out > LongName;
};
// C++ wrapper for IfcSphere
struct IfcSphere : IfcCsgPrimitive3D, ObjectHelper<IfcSphere,1> { IfcSphere() : Object("IfcSphere") {}
IfcPositiveLengthMeasure::Out Radius;
};
// C++ wrapper for IfcSphericalSurface
struct IfcSphericalSurface : IfcElementarySurface, ObjectHelper<IfcSphericalSurface,1> { IfcSphericalSurface() : Object("IfcSphericalSurface") {}
IfcPositiveLengthMeasure::Out Radius;
};
// C++ wrapper for IfcStackTerminal
struct IfcStackTerminal : IfcFlowTerminal, ObjectHelper<IfcStackTerminal,1> { IfcStackTerminal() : Object("IfcStackTerminal") {}
Maybe< IfcStackTerminalTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcStackTerminalType
struct IfcStackTerminalType : IfcFlowTerminalType, ObjectHelper<IfcStackTerminalType,1> { IfcStackTerminalType() : Object("IfcStackTerminalType") {}
IfcStackTerminalTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcStair
struct IfcStair : IfcBuildingElement, ObjectHelper<IfcStair,1> { IfcStair() : Object("IfcStair") {}
Maybe< IfcStairTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcStairFlight
struct IfcStairFlight : IfcBuildingElement, ObjectHelper<IfcStairFlight,5> { IfcStairFlight() : Object("IfcStairFlight") {}
Maybe< IfcInteger::Out > NumberOfRisers;
Maybe< IfcInteger::Out > NumberOfTreads;
Maybe< IfcPositiveLengthMeasure::Out > RiserHeight;
Maybe< IfcPositiveLengthMeasure::Out > TreadLength;
Maybe< IfcStairFlightTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcStairFlightType
struct IfcStairFlightType : IfcBuildingElementType, ObjectHelper<IfcStairFlightType,1> { IfcStairFlightType() : Object("IfcStairFlightType") {}
IfcStairFlightTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcStairType
struct IfcStairType : IfcBuildingElementType, ObjectHelper<IfcStairType,1> { IfcStairType() : Object("IfcStairType") {}
IfcStairTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcStructuralActivity
struct IfcStructuralActivity : IfcProduct, ObjectHelper<IfcStructuralActivity,2> { IfcStructuralActivity() : Object("IfcStructuralActivity") {}
Lazy< NotImplemented > AppliedLoad;
IfcGlobalOrLocalEnum::Out GlobalOrLocal;
};
// C++ wrapper for IfcStructuralAction
struct IfcStructuralAction : IfcStructuralActivity, ObjectHelper<IfcStructuralAction,1> { IfcStructuralAction() : Object("IfcStructuralAction") {}
Maybe< IfcBoolean::Out > DestabilizingLoad;
};
// C++ wrapper for IfcStructuralAnalysisModel
struct IfcStructuralAnalysisModel : IfcSystem, ObjectHelper<IfcStructuralAnalysisModel,5> { IfcStructuralAnalysisModel() : Object("IfcStructuralAnalysisModel") {}
IfcAnalysisModelTypeEnum::Out PredefinedType;
Maybe< Lazy< IfcAxis2Placement3D > > OrientationOf2DPlane;
Maybe< ListOf< Lazy< IfcStructuralLoadGroup >, 1, 0 > > LoadedBy;
Maybe< ListOf< Lazy< IfcStructuralResultGroup >, 1, 0 > > HasResults;
Maybe< Lazy< IfcObjectPlacement > > SharedPlacement;
};
// C++ wrapper for IfcStructuralItem
struct IfcStructuralItem : IfcProduct, ObjectHelper<IfcStructuralItem,0> { IfcStructuralItem() : Object("IfcStructuralItem") {}
};
// C++ wrapper for IfcStructuralConnection
struct IfcStructuralConnection : IfcStructuralItem, ObjectHelper<IfcStructuralConnection,1> { IfcStructuralConnection() : Object("IfcStructuralConnection") {}
Maybe< Lazy< NotImplemented > > AppliedCondition;
};
// C++ wrapper for IfcStructuralCurveAction
struct IfcStructuralCurveAction : IfcStructuralAction, ObjectHelper<IfcStructuralCurveAction,2> { IfcStructuralCurveAction() : Object("IfcStructuralCurveAction") {}
Maybe< IfcProjectedOrTrueLengthEnum::Out > ProjectedOrTrue;
IfcStructuralCurveActivityTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcStructuralCurveConnection
struct IfcStructuralCurveConnection : IfcStructuralConnection, ObjectHelper<IfcStructuralCurveConnection,1> { IfcStructuralCurveConnection() : Object("IfcStructuralCurveConnection") {}
Lazy< IfcDirection > Axis;
};
// C++ wrapper for IfcStructuralMember
struct IfcStructuralMember : IfcStructuralItem, ObjectHelper<IfcStructuralMember,0> { IfcStructuralMember() : Object("IfcStructuralMember") {}
};
// C++ wrapper for IfcStructuralCurveMember
struct IfcStructuralCurveMember : IfcStructuralMember, ObjectHelper<IfcStructuralCurveMember,2> { IfcStructuralCurveMember() : Object("IfcStructuralCurveMember") {}
IfcStructuralCurveMemberTypeEnum::Out PredefinedType;
Lazy< IfcDirection > Axis;
};
// C++ wrapper for IfcStructuralCurveMemberVarying
struct IfcStructuralCurveMemberVarying : IfcStructuralCurveMember, ObjectHelper<IfcStructuralCurveMemberVarying,0> { IfcStructuralCurveMemberVarying() : Object("IfcStructuralCurveMemberVarying") {}
};
// C++ wrapper for IfcStructuralReaction
struct IfcStructuralReaction : IfcStructuralActivity, ObjectHelper<IfcStructuralReaction,0> { IfcStructuralReaction() : Object("IfcStructuralReaction") {}
};
// C++ wrapper for IfcStructuralCurveReaction
struct IfcStructuralCurveReaction : IfcStructuralReaction, ObjectHelper<IfcStructuralCurveReaction,1> { IfcStructuralCurveReaction() : Object("IfcStructuralCurveReaction") {}
IfcStructuralCurveActivityTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcStructuralLinearAction
struct IfcStructuralLinearAction : IfcStructuralCurveAction, ObjectHelper<IfcStructuralLinearAction,0> { IfcStructuralLinearAction() : Object("IfcStructuralLinearAction") {}
};
// C++ wrapper for IfcStructuralLoadGroup
struct IfcStructuralLoadGroup : IfcGroup, ObjectHelper<IfcStructuralLoadGroup,5> { IfcStructuralLoadGroup() : Object("IfcStructuralLoadGroup") {}
IfcLoadGroupTypeEnum::Out PredefinedType;
IfcActionTypeEnum::Out ActionType;
IfcActionSourceTypeEnum::Out ActionSource;
Maybe< IfcRatioMeasure::Out > Coefficient;
Maybe< IfcLabel::Out > Purpose;
};
// C++ wrapper for IfcStructuralLoadCase
struct IfcStructuralLoadCase : IfcStructuralLoadGroup, ObjectHelper<IfcStructuralLoadCase,1> { IfcStructuralLoadCase() : Object("IfcStructuralLoadCase") {}
Maybe< ListOf< IfcRatioMeasure, 3, 3 >::Out > SelfWeightCoefficients;
};
// C++ wrapper for IfcStructuralSurfaceAction
struct IfcStructuralSurfaceAction : IfcStructuralAction, ObjectHelper<IfcStructuralSurfaceAction,2> { IfcStructuralSurfaceAction() : Object("IfcStructuralSurfaceAction") {}
Maybe< IfcProjectedOrTrueLengthEnum::Out > ProjectedOrTrue;
IfcStructuralSurfaceActivityTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcStructuralPlanarAction
struct IfcStructuralPlanarAction : IfcStructuralSurfaceAction, ObjectHelper<IfcStructuralPlanarAction,0> { IfcStructuralPlanarAction() : Object("IfcStructuralPlanarAction") {}
};
// C++ wrapper for IfcStructuralPointAction
struct IfcStructuralPointAction : IfcStructuralAction, ObjectHelper<IfcStructuralPointAction,0> { IfcStructuralPointAction() : Object("IfcStructuralPointAction") {}
};
// C++ wrapper for IfcStructuralPointConnection
struct IfcStructuralPointConnection : IfcStructuralConnection, ObjectHelper<IfcStructuralPointConnection,1> { IfcStructuralPointConnection() : Object("IfcStructuralPointConnection") {}
Maybe< Lazy< IfcAxis2Placement3D > > ConditionCoordinateSystem;
};
// C++ wrapper for IfcStructuralPointReaction
struct IfcStructuralPointReaction : IfcStructuralReaction, ObjectHelper<IfcStructuralPointReaction,0> { IfcStructuralPointReaction() : Object("IfcStructuralPointReaction") {}
};
// C++ wrapper for IfcStructuralResultGroup
struct IfcStructuralResultGroup : IfcGroup, ObjectHelper<IfcStructuralResultGroup,3> { IfcStructuralResultGroup() : Object("IfcStructuralResultGroup") {}
IfcAnalysisTheoryTypeEnum::Out TheoryType;
Maybe< Lazy< IfcStructuralLoadGroup > > ResultForLoadGroup;
IfcBoolean::Out IsLinear;
};
// C++ wrapper for IfcStructuralSurfaceConnection
struct IfcStructuralSurfaceConnection : IfcStructuralConnection, ObjectHelper<IfcStructuralSurfaceConnection,0> { IfcStructuralSurfaceConnection() : Object("IfcStructuralSurfaceConnection") {}
};
// C++ wrapper for IfcStructuralSurfaceMember
struct IfcStructuralSurfaceMember : IfcStructuralMember, ObjectHelper<IfcStructuralSurfaceMember,2> { IfcStructuralSurfaceMember() : Object("IfcStructuralSurfaceMember") {}
IfcStructuralSurfaceMemberTypeEnum::Out PredefinedType;
Maybe< IfcPositiveLengthMeasure::Out > Thickness;
};
// C++ wrapper for IfcStructuralSurfaceMemberVarying
struct IfcStructuralSurfaceMemberVarying : IfcStructuralSurfaceMember, ObjectHelper<IfcStructuralSurfaceMemberVarying,0> { IfcStructuralSurfaceMemberVarying() : Object("IfcStructuralSurfaceMemberVarying") {}
};
// C++ wrapper for IfcStructuralSurfaceReaction
struct IfcStructuralSurfaceReaction : IfcStructuralReaction, ObjectHelper<IfcStructuralSurfaceReaction,1> { IfcStructuralSurfaceReaction() : Object("IfcStructuralSurfaceReaction") {}
IfcStructuralSurfaceActivityTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcStyleModel
struct IfcStyleModel : IfcRepresentation, ObjectHelper<IfcStyleModel,0> { IfcStyleModel() : Object("IfcStyleModel") {}
};
// C++ wrapper for IfcStyledItem
struct IfcStyledItem : IfcRepresentationItem, ObjectHelper<IfcStyledItem,3> { IfcStyledItem() : Object("IfcStyledItem") {}
Maybe< Lazy< IfcRepresentationItem > > Item;
ListOf< IfcStyleAssignmentSelect, 1, 0 >::Out Styles;
Maybe< IfcLabel::Out > Name;
};
// C++ wrapper for IfcStyledRepresentation
struct IfcStyledRepresentation : IfcStyleModel, ObjectHelper<IfcStyledRepresentation,0> { IfcStyledRepresentation() : Object("IfcStyledRepresentation") {}
};
// C++ wrapper for IfcSubContractResource
struct IfcSubContractResource : IfcConstructionResource, ObjectHelper<IfcSubContractResource,1> { IfcSubContractResource() : Object("IfcSubContractResource") {}
Maybe< IfcSubContractResourceTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcSubContractResourceType
struct IfcSubContractResourceType : IfcConstructionResourceType, ObjectHelper<IfcSubContractResourceType,1> { IfcSubContractResourceType() : Object("IfcSubContractResourceType") {}
IfcSubContractResourceTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcSubedge
struct IfcSubedge : IfcEdge, ObjectHelper<IfcSubedge,1> { IfcSubedge() : Object("IfcSubedge") {}
Lazy< IfcEdge > ParentEdge;
};
// C++ wrapper for IfcSurfaceCurveSweptAreaSolid
struct IfcSurfaceCurveSweptAreaSolid : IfcSweptAreaSolid, ObjectHelper<IfcSurfaceCurveSweptAreaSolid,4> { IfcSurfaceCurveSweptAreaSolid() : Object("IfcSurfaceCurveSweptAreaSolid") {}
Lazy< IfcCurve > Directrix;
Maybe< IfcParameterValue::Out > StartParam;
Maybe< IfcParameterValue::Out > EndParam;
Lazy< IfcSurface > ReferenceSurface;
};
// C++ wrapper for IfcSurfaceFeature
struct IfcSurfaceFeature : IfcFeatureElement, ObjectHelper<IfcSurfaceFeature,1> { IfcSurfaceFeature() : Object("IfcSurfaceFeature") {}
Maybe< IfcSurfaceFeatureTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcSweptSurface
struct IfcSweptSurface : IfcSurface, ObjectHelper<IfcSweptSurface,2> { IfcSweptSurface() : Object("IfcSweptSurface") {}
Lazy< IfcProfileDef > SweptCurve;
Maybe< Lazy< IfcAxis2Placement3D > > Position;
};
// C++ wrapper for IfcSurfaceOfLinearExtrusion
struct IfcSurfaceOfLinearExtrusion : IfcSweptSurface, ObjectHelper<IfcSurfaceOfLinearExtrusion,2> { IfcSurfaceOfLinearExtrusion() : Object("IfcSurfaceOfLinearExtrusion") {}
Lazy< IfcDirection > ExtrudedDirection;
IfcLengthMeasure::Out Depth;
};
// C++ wrapper for IfcSurfaceOfRevolution
struct IfcSurfaceOfRevolution : IfcSweptSurface, ObjectHelper<IfcSurfaceOfRevolution,1> { IfcSurfaceOfRevolution() : Object("IfcSurfaceOfRevolution") {}
Lazy< IfcAxis1Placement > AxisPosition;
};
// C++ wrapper for IfcSurfaceStyle
struct IfcSurfaceStyle : IfcPresentationStyle, ObjectHelper<IfcSurfaceStyle,2> { IfcSurfaceStyle() : Object("IfcSurfaceStyle") {}
IfcSurfaceSide::Out Side;
ListOf< IfcSurfaceStyleElementSelect, 1, 5 >::Out Styles;
};
// C++ wrapper for IfcSurfaceStyleShading
struct IfcSurfaceStyleShading : IfcPresentationItem, ObjectHelper<IfcSurfaceStyleShading,2> { IfcSurfaceStyleShading() : Object("IfcSurfaceStyleShading") {}
Lazy< IfcColourRgb > SurfaceColour;
Maybe< IfcNormalisedRatioMeasure::Out > Transparency;
};
// C++ wrapper for IfcSurfaceStyleRendering
struct IfcSurfaceStyleRendering : IfcSurfaceStyleShading, ObjectHelper<IfcSurfaceStyleRendering,7> { IfcSurfaceStyleRendering() : Object("IfcSurfaceStyleRendering") {}
Maybe< IfcColourOrFactor::Out > DiffuseColour;
Maybe< IfcColourOrFactor::Out > TransmissionColour;
Maybe< IfcColourOrFactor::Out > DiffuseTransmissionColour;
Maybe< IfcColourOrFactor::Out > ReflectionColour;
Maybe< IfcColourOrFactor::Out > SpecularColour;
Maybe< IfcSpecularHighlightSelect::Out > SpecularHighlight;
IfcReflectanceMethodEnum::Out ReflectanceMethod;
};
// C++ wrapper for IfcSurfaceStyleWithTextures
struct IfcSurfaceStyleWithTextures : IfcPresentationItem, ObjectHelper<IfcSurfaceStyleWithTextures,1> { IfcSurfaceStyleWithTextures() : Object("IfcSurfaceStyleWithTextures") {}
ListOf< Lazy< NotImplemented >, 1, 0 > Textures;
};
// C++ wrapper for IfcSweptDiskSolid
struct IfcSweptDiskSolid : IfcSolidModel, ObjectHelper<IfcSweptDiskSolid,5> { IfcSweptDiskSolid() : Object("IfcSweptDiskSolid") {}
Lazy< IfcCurve > Directrix;
IfcPositiveLengthMeasure::Out Radius;
Maybe< IfcPositiveLengthMeasure::Out > InnerRadius;
Maybe< IfcParameterValue::Out > StartParam;
Maybe< IfcParameterValue::Out > EndParam;
};
// C++ wrapper for IfcSweptDiskSolidPolygonal
struct IfcSweptDiskSolidPolygonal : IfcSweptDiskSolid, ObjectHelper<IfcSweptDiskSolidPolygonal,1> { IfcSweptDiskSolidPolygonal() : Object("IfcSweptDiskSolidPolygonal") {}
Maybe< IfcPositiveLengthMeasure::Out > FilletRadius;
};
// C++ wrapper for IfcSwitchingDevice
struct IfcSwitchingDevice : IfcFlowController, ObjectHelper<IfcSwitchingDevice,1> { IfcSwitchingDevice() : Object("IfcSwitchingDevice") {}
Maybe< IfcSwitchingDeviceTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcSwitchingDeviceType
struct IfcSwitchingDeviceType : IfcFlowControllerType, ObjectHelper<IfcSwitchingDeviceType,1> { IfcSwitchingDeviceType() : Object("IfcSwitchingDeviceType") {}
IfcSwitchingDeviceTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcSystemFurnitureElement
struct IfcSystemFurnitureElement : IfcFurnishingElement, ObjectHelper<IfcSystemFurnitureElement,1> { IfcSystemFurnitureElement() : Object("IfcSystemFurnitureElement") {}
Maybe< IfcSystemFurnitureElementTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcSystemFurnitureElementType
struct IfcSystemFurnitureElementType : IfcFurnishingElementType, ObjectHelper<IfcSystemFurnitureElementType,1> { IfcSystemFurnitureElementType() : Object("IfcSystemFurnitureElementType") {}
Maybe< IfcSystemFurnitureElementTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcTShapeProfileDef
struct IfcTShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcTShapeProfileDef,9> { IfcTShapeProfileDef() : Object("IfcTShapeProfileDef") {}
IfcPositiveLengthMeasure::Out Depth;
IfcPositiveLengthMeasure::Out FlangeWidth;
IfcPositiveLengthMeasure::Out WebThickness;
IfcPositiveLengthMeasure::Out FlangeThickness;
Maybe< IfcNonNegativeLengthMeasure::Out > FilletRadius;
Maybe< IfcNonNegativeLengthMeasure::Out > FlangeEdgeRadius;
Maybe< IfcNonNegativeLengthMeasure::Out > WebEdgeRadius;
Maybe< IfcPlaneAngleMeasure::Out > WebSlope;
Maybe< IfcPlaneAngleMeasure::Out > FlangeSlope;
};
// C++ wrapper for IfcTank
struct IfcTank : IfcFlowStorageDevice, ObjectHelper<IfcTank,1> { IfcTank() : Object("IfcTank") {}
Maybe< IfcTankTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcTankType
struct IfcTankType : IfcFlowStorageDeviceType, ObjectHelper<IfcTankType,1> { IfcTankType() : Object("IfcTankType") {}
IfcTankTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcTask
struct IfcTask : IfcProcess, ObjectHelper<IfcTask,6> { IfcTask() : Object("IfcTask") {}
Maybe< IfcLabel::Out > Status;
Maybe< IfcLabel::Out > WorkMethod;
IfcBoolean::Out IsMilestone;
Maybe< IfcInteger::Out > Priority;
Maybe< Lazy< NotImplemented > > TaskTime;
Maybe< IfcTaskTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcTaskType
struct IfcTaskType : IfcTypeProcess, ObjectHelper<IfcTaskType,2> { IfcTaskType() : Object("IfcTaskType") {}
IfcTaskTypeEnum::Out PredefinedType;
Maybe< IfcLabel::Out > WorkMethod;
};
// C++ wrapper for IfcTendon
struct IfcTendon : IfcReinforcingElement, ObjectHelper<IfcTendon,8> { IfcTendon() : Object("IfcTendon") {}
Maybe< IfcTendonTypeEnum::Out > PredefinedType;
Maybe< IfcPositiveLengthMeasure::Out > NominalDiameter;
Maybe< IfcAreaMeasure::Out > CrossSectionArea;
Maybe< IfcForceMeasure::Out > TensionForce;
Maybe< IfcPressureMeasure::Out > PreStress;
Maybe< IfcNormalisedRatioMeasure::Out > FrictionCoefficient;
Maybe< IfcPositiveLengthMeasure::Out > AnchorageSlip;
Maybe< IfcPositiveLengthMeasure::Out > MinCurvatureRadius;
};
// C++ wrapper for IfcTendonAnchor
struct IfcTendonAnchor : IfcReinforcingElement, ObjectHelper<IfcTendonAnchor,1> { IfcTendonAnchor() : Object("IfcTendonAnchor") {}
Maybe< IfcTendonAnchorTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcTendonAnchorType
struct IfcTendonAnchorType : IfcReinforcingElementType, ObjectHelper<IfcTendonAnchorType,1> { IfcTendonAnchorType() : Object("IfcTendonAnchorType") {}
IfcTendonAnchorTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcTendonType
struct IfcTendonType : IfcReinforcingElementType, ObjectHelper<IfcTendonType,4> { IfcTendonType() : Object("IfcTendonType") {}
IfcTendonTypeEnum::Out PredefinedType;
Maybe< IfcPositiveLengthMeasure::Out > NominalDiameter;
Maybe< IfcAreaMeasure::Out > CrossSectionArea;
Maybe< IfcPositiveLengthMeasure::Out > SheathDiameter;
};
// C++ wrapper for IfcTextLiteral
struct IfcTextLiteral : IfcGeometricRepresentationItem, ObjectHelper<IfcTextLiteral,3> { IfcTextLiteral() : Object("IfcTextLiteral") {}
IfcPresentableText::Out Literal;
IfcAxis2Placement::Out Placement;
IfcTextPath::Out Path;
};
// C++ wrapper for IfcTextLiteralWithExtent
struct IfcTextLiteralWithExtent : IfcTextLiteral, ObjectHelper<IfcTextLiteralWithExtent,2> { IfcTextLiteralWithExtent() : Object("IfcTextLiteralWithExtent") {}
Lazy< IfcPlanarExtent > Extent;
IfcBoxAlignment::Out BoxAlignment;
};
// C++ wrapper for IfcTopologyRepresentation
struct IfcTopologyRepresentation : IfcShapeModel, ObjectHelper<IfcTopologyRepresentation,0> { IfcTopologyRepresentation() : Object("IfcTopologyRepresentation") {}
};
// C++ wrapper for IfcToroidalSurface
struct IfcToroidalSurface : IfcElementarySurface, ObjectHelper<IfcToroidalSurface,2> { IfcToroidalSurface() : Object("IfcToroidalSurface") {}
IfcPositiveLengthMeasure::Out MajorRadius;
IfcPositiveLengthMeasure::Out MinorRadius;
};
// C++ wrapper for IfcTransformer
struct IfcTransformer : IfcEnergyConversionDevice, ObjectHelper<IfcTransformer,1> { IfcTransformer() : Object("IfcTransformer") {}
Maybe< IfcTransformerTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcTransformerType
struct IfcTransformerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcTransformerType,1> { IfcTransformerType() : Object("IfcTransformerType") {}
IfcTransformerTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcTransportElement
struct IfcTransportElement : IfcElement, ObjectHelper<IfcTransportElement,1> { IfcTransportElement() : Object("IfcTransportElement") {}
Maybe< IfcTransportElementTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcTransportElementType
struct IfcTransportElementType : IfcElementType, ObjectHelper<IfcTransportElementType,1> { IfcTransportElementType() : Object("IfcTransportElementType") {}
IfcTransportElementTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcTrapeziumProfileDef
struct IfcTrapeziumProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcTrapeziumProfileDef,4> { IfcTrapeziumProfileDef() : Object("IfcTrapeziumProfileDef") {}
IfcPositiveLengthMeasure::Out BottomXDim;
IfcPositiveLengthMeasure::Out TopXDim;
IfcPositiveLengthMeasure::Out YDim;
IfcLengthMeasure::Out TopXOffset;
};
// C++ wrapper for IfcTriangulatedFaceSet
struct IfcTriangulatedFaceSet : IfcTessellatedFaceSet, ObjectHelper<IfcTriangulatedFaceSet,2> { IfcTriangulatedFaceSet() : Object("IfcTriangulatedFaceSet") {}
Maybe< IfcBoolean::Out > Closed;
Maybe< ListOf< IfcPositiveInteger, 1, 0 >::Out > PnIndex;
};
// C++ wrapper for IfcTrimmedCurve
struct IfcTrimmedCurve : IfcBoundedCurve, ObjectHelper<IfcTrimmedCurve,5> { IfcTrimmedCurve() : Object("IfcTrimmedCurve") {}
Lazy< IfcCurve > BasisCurve;
ListOf< IfcTrimmingSelect, 1, 2 >::Out Trim1;
ListOf< IfcTrimmingSelect, 1, 2 >::Out Trim2;
IfcBoolean::Out SenseAgreement;
IfcTrimmingPreference::Out MasterRepresentation;
};
// C++ wrapper for IfcTubeBundle
struct IfcTubeBundle : IfcEnergyConversionDevice, ObjectHelper<IfcTubeBundle,1> { IfcTubeBundle() : Object("IfcTubeBundle") {}
Maybe< IfcTubeBundleTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcTubeBundleType
struct IfcTubeBundleType : IfcEnergyConversionDeviceType, ObjectHelper<IfcTubeBundleType,1> { IfcTubeBundleType() : Object("IfcTubeBundleType") {}
IfcTubeBundleTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcUShapeProfileDef
struct IfcUShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcUShapeProfileDef,7> { IfcUShapeProfileDef() : Object("IfcUShapeProfileDef") {}
IfcPositiveLengthMeasure::Out Depth;
IfcPositiveLengthMeasure::Out FlangeWidth;
IfcPositiveLengthMeasure::Out WebThickness;
IfcPositiveLengthMeasure::Out FlangeThickness;
Maybe< IfcNonNegativeLengthMeasure::Out > FilletRadius;
Maybe< IfcNonNegativeLengthMeasure::Out > EdgeRadius;
Maybe< IfcPlaneAngleMeasure::Out > FlangeSlope;
};
// C++ wrapper for IfcUnitAssignment
struct IfcUnitAssignment : ObjectHelper<IfcUnitAssignment,1> { IfcUnitAssignment() : Object("IfcUnitAssignment") {}
ListOf< IfcUnit, 1, 0 >::Out Units;
};
// C++ wrapper for IfcUnitaryControlElement
struct IfcUnitaryControlElement : IfcDistributionControlElement, ObjectHelper<IfcUnitaryControlElement,1> { IfcUnitaryControlElement() : Object("IfcUnitaryControlElement") {}
Maybe< IfcUnitaryControlElementTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcUnitaryControlElementType
struct IfcUnitaryControlElementType : IfcDistributionControlElementType, ObjectHelper<IfcUnitaryControlElementType,1> { IfcUnitaryControlElementType() : Object("IfcUnitaryControlElementType") {}
IfcUnitaryControlElementTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcUnitaryEquipment
struct IfcUnitaryEquipment : IfcEnergyConversionDevice, ObjectHelper<IfcUnitaryEquipment,1> { IfcUnitaryEquipment() : Object("IfcUnitaryEquipment") {}
Maybe< IfcUnitaryEquipmentTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcUnitaryEquipmentType
struct IfcUnitaryEquipmentType : IfcEnergyConversionDeviceType, ObjectHelper<IfcUnitaryEquipmentType,1> { IfcUnitaryEquipmentType() : Object("IfcUnitaryEquipmentType") {}
IfcUnitaryEquipmentTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcValve
struct IfcValve : IfcFlowController, ObjectHelper<IfcValve,1> { IfcValve() : Object("IfcValve") {}
Maybe< IfcValveTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcValveType
struct IfcValveType : IfcFlowControllerType, ObjectHelper<IfcValveType,1> { IfcValveType() : Object("IfcValveType") {}
IfcValveTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcVector
struct IfcVector : IfcGeometricRepresentationItem, ObjectHelper<IfcVector,2> { IfcVector() : Object("IfcVector") {}
Lazy< IfcDirection > Orientation;
IfcLengthMeasure::Out Magnitude;
};
// C++ wrapper for IfcVertex
struct IfcVertex : IfcTopologicalRepresentationItem, ObjectHelper<IfcVertex,0> { IfcVertex() : Object("IfcVertex") {}
};
// C++ wrapper for IfcVertexLoop
struct IfcVertexLoop : IfcLoop, ObjectHelper<IfcVertexLoop,1> { IfcVertexLoop() : Object("IfcVertexLoop") {}
Lazy< IfcVertex > LoopVertex;
};
// C++ wrapper for IfcVertexPoint
struct IfcVertexPoint : IfcVertex, ObjectHelper<IfcVertexPoint,1> { IfcVertexPoint() : Object("IfcVertexPoint") {}
Lazy< IfcPoint > VertexGeometry;
};
// C++ wrapper for IfcVibrationIsolator
struct IfcVibrationIsolator : IfcElementComponent, ObjectHelper<IfcVibrationIsolator,1> { IfcVibrationIsolator() : Object("IfcVibrationIsolator") {}
Maybe< IfcVibrationIsolatorTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcVibrationIsolatorType
struct IfcVibrationIsolatorType : IfcElementComponentType, ObjectHelper<IfcVibrationIsolatorType,1> { IfcVibrationIsolatorType() : Object("IfcVibrationIsolatorType") {}
IfcVibrationIsolatorTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcVirtualElement
struct IfcVirtualElement : IfcElement, ObjectHelper<IfcVirtualElement,0> { IfcVirtualElement() : Object("IfcVirtualElement") {}
};
// C++ wrapper for IfcVoidingFeature
struct IfcVoidingFeature : IfcFeatureElementSubtraction, ObjectHelper<IfcVoidingFeature,1> { IfcVoidingFeature() : Object("IfcVoidingFeature") {}
Maybe< IfcVoidingFeatureTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcWall
struct IfcWall : IfcBuildingElement, ObjectHelper<IfcWall,1> { IfcWall() : Object("IfcWall") {}
Maybe< IfcWallTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcWallElementedCase
struct IfcWallElementedCase : IfcWall, ObjectHelper<IfcWallElementedCase,0> { IfcWallElementedCase() : Object("IfcWallElementedCase") {}
};
// C++ wrapper for IfcWallStandardCase
struct IfcWallStandardCase : IfcWall, ObjectHelper<IfcWallStandardCase,0> { IfcWallStandardCase() : Object("IfcWallStandardCase") {}
};
// C++ wrapper for IfcWallType
struct IfcWallType : IfcBuildingElementType, ObjectHelper<IfcWallType,1> { IfcWallType() : Object("IfcWallType") {}
IfcWallTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcWasteTerminal
struct IfcWasteTerminal : IfcFlowTerminal, ObjectHelper<IfcWasteTerminal,1> { IfcWasteTerminal() : Object("IfcWasteTerminal") {}
Maybe< IfcWasteTerminalTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcWasteTerminalType
struct IfcWasteTerminalType : IfcFlowTerminalType, ObjectHelper<IfcWasteTerminalType,1> { IfcWasteTerminalType() : Object("IfcWasteTerminalType") {}
IfcWasteTerminalTypeEnum::Out PredefinedType;
};
// C++ wrapper for IfcWindow
struct IfcWindow : IfcBuildingElement, ObjectHelper<IfcWindow,5> { IfcWindow() : Object("IfcWindow") {}
Maybe< IfcPositiveLengthMeasure::Out > OverallHeight;
Maybe< IfcPositiveLengthMeasure::Out > OverallWidth;
Maybe< IfcWindowTypeEnum::Out > PredefinedType;
Maybe< IfcWindowTypePartitioningEnum::Out > PartitioningType;
Maybe< IfcLabel::Out > UserDefinedPartitioningType;
};
// C++ wrapper for IfcWindowStandardCase
struct IfcWindowStandardCase : IfcWindow, ObjectHelper<IfcWindowStandardCase,0> { IfcWindowStandardCase() : Object("IfcWindowStandardCase") {}
};
// C++ wrapper for IfcWindowStyle
struct IfcWindowStyle : IfcTypeProduct, ObjectHelper<IfcWindowStyle,4> { IfcWindowStyle() : Object("IfcWindowStyle") {}
IfcWindowStyleConstructionEnum::Out ConstructionType;
IfcWindowStyleOperationEnum::Out OperationType;
IfcBoolean::Out ParameterTakesPrecedence;
IfcBoolean::Out Sizeable;
};
// C++ wrapper for IfcWindowType
struct IfcWindowType : IfcBuildingElementType, ObjectHelper<IfcWindowType,4> { IfcWindowType() : Object("IfcWindowType") {}
IfcWindowTypeEnum::Out PredefinedType;
IfcWindowTypePartitioningEnum::Out PartitioningType;
Maybe< IfcBoolean::Out > ParameterTakesPrecedence;
Maybe< IfcLabel::Out > UserDefinedPartitioningType;
};
// C++ wrapper for IfcWorkCalendar
struct IfcWorkCalendar : IfcControl, ObjectHelper<IfcWorkCalendar,3> { IfcWorkCalendar() : Object("IfcWorkCalendar") {}
Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > WorkingTimes;
Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > ExceptionTimes;
Maybe< IfcWorkCalendarTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcWorkControl
struct IfcWorkControl : IfcControl, ObjectHelper<IfcWorkControl,7> { IfcWorkControl() : Object("IfcWorkControl") {}
IfcDateTime::Out CreationDate;
Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > Creators;
Maybe< IfcLabel::Out > Purpose;
Maybe< IfcDuration::Out > Duration;
Maybe< IfcDuration::Out > TotalFloat;
IfcDateTime::Out StartTime;
Maybe< IfcDateTime::Out > FinishTime;
};
// C++ wrapper for IfcWorkPlan
struct IfcWorkPlan : IfcWorkControl, ObjectHelper<IfcWorkPlan,1> { IfcWorkPlan() : Object("IfcWorkPlan") {}
Maybe< IfcWorkPlanTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcWorkSchedule
struct IfcWorkSchedule : IfcWorkControl, ObjectHelper<IfcWorkSchedule,1> { IfcWorkSchedule() : Object("IfcWorkSchedule") {}
Maybe< IfcWorkScheduleTypeEnum::Out > PredefinedType;
};
// C++ wrapper for IfcZShapeProfileDef
struct IfcZShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcZShapeProfileDef,6> { IfcZShapeProfileDef() : Object("IfcZShapeProfileDef") {}
IfcPositiveLengthMeasure::Out Depth;
IfcPositiveLengthMeasure::Out FlangeWidth;
IfcPositiveLengthMeasure::Out WebThickness;
IfcPositiveLengthMeasure::Out FlangeThickness;
Maybe< IfcNonNegativeLengthMeasure::Out > FilletRadius;
Maybe< IfcNonNegativeLengthMeasure::Out > EdgeRadius;
};
// C++ wrapper for IfcZone
struct IfcZone : IfcSystem, ObjectHelper<IfcZone,1> { IfcZone() : Object("IfcZone") {}
Maybe< IfcLabel::Out > LongName;
};
void GetSchema(EXPRESS::ConversionSchema& out);
} //! IFC
namespace STEP {
closes https://github.com/assimp/assimp/issues/1752: move guard over include statement.
2018-02-03 07:46:03 +00:00
// ******************************************************************************
// Converter stubs
// ******************************************************************************
IFC: introduce new namespace fpr IFC-schema2x3
2018-01-13 09:27:45 +00:00
#define DECL_CONV_STUB(type) template <> size_t GenericFill<IFC::type>(const STEP::DB& db, const EXPRESS::LIST& params, IFC::type* in)
closes https://github.com/assimp/assimp/issues/1752: move guard over include statement.
2018-02-03 07:46:03 +00:00
DECL_CONV_STUB( IfcRoot );
DECL_CONV_STUB( IfcObjectDefinition );
DECL_CONV_STUB( IfcObject );
DECL_CONV_STUB( IfcControl );
DECL_CONV_STUB( IfcActionRequest );
DECL_CONV_STUB( IfcActor );
DECL_CONV_STUB( IfcProduct );
DECL_CONV_STUB( IfcElement );
DECL_CONV_STUB( IfcDistributionElement );
DECL_CONV_STUB( IfcDistributionControlElement );
DECL_CONV_STUB( IfcActuator );
DECL_CONV_STUB( IfcTypeObject );
DECL_CONV_STUB( IfcTypeProduct );
DECL_CONV_STUB( IfcElementType );
DECL_CONV_STUB( IfcDistributionElementType );
DECL_CONV_STUB( IfcDistributionControlElementType );
DECL_CONV_STUB( IfcActuatorType );
DECL_CONV_STUB( IfcRepresentationItem );
DECL_CONV_STUB( IfcGeometricRepresentationItem );
DECL_CONV_STUB( IfcSolidModel );
DECL_CONV_STUB( IfcManifoldSolidBrep );
DECL_CONV_STUB( IfcAdvancedBrep );
DECL_CONV_STUB( IfcAdvancedBrepWithVoids );
DECL_CONV_STUB( IfcTopologicalRepresentationItem );
DECL_CONV_STUB( IfcFace );
DECL_CONV_STUB( IfcFaceSurface );
DECL_CONV_STUB( IfcAdvancedFace );
DECL_CONV_STUB( IfcDistributionFlowElement );
DECL_CONV_STUB( IfcFlowTerminal );
DECL_CONV_STUB( IfcAirTerminal );
DECL_CONV_STUB( IfcFlowController );
DECL_CONV_STUB( IfcAirTerminalBox );
DECL_CONV_STUB( IfcDistributionFlowElementType );
DECL_CONV_STUB( IfcFlowControllerType );
DECL_CONV_STUB( IfcAirTerminalBoxType );
DECL_CONV_STUB( IfcFlowTerminalType );
DECL_CONV_STUB( IfcAirTerminalType );
DECL_CONV_STUB( IfcEnergyConversionDevice );
DECL_CONV_STUB( IfcAirToAirHeatRecovery );
DECL_CONV_STUB( IfcEnergyConversionDeviceType );
DECL_CONV_STUB( IfcAirToAirHeatRecoveryType );
DECL_CONV_STUB( IfcAlarm );
DECL_CONV_STUB( IfcAlarmType );
DECL_CONV_STUB( IfcAnnotation );
DECL_CONV_STUB( IfcAnnotationFillArea );
DECL_CONV_STUB( IfcProfileDef );
DECL_CONV_STUB( IfcArbitraryClosedProfileDef );
DECL_CONV_STUB( IfcArbitraryOpenProfileDef );
DECL_CONV_STUB( IfcArbitraryProfileDefWithVoids );
DECL_CONV_STUB( IfcGroup );
DECL_CONV_STUB( IfcAsset );
DECL_CONV_STUB( IfcParameterizedProfileDef );
DECL_CONV_STUB( IfcAsymmetricIShapeProfileDef );
DECL_CONV_STUB( IfcAudioVisualAppliance );
DECL_CONV_STUB( IfcAudioVisualApplianceType );
DECL_CONV_STUB( IfcPlacement );
DECL_CONV_STUB( IfcAxis1Placement );
DECL_CONV_STUB( IfcAxis2Placement2D );
DECL_CONV_STUB( IfcAxis2Placement3D );
DECL_CONV_STUB( IfcCurve );
DECL_CONV_STUB( IfcBoundedCurve );
DECL_CONV_STUB( IfcBSplineCurve );
DECL_CONV_STUB( IfcBSplineCurveWithKnots );
DECL_CONV_STUB( IfcSurface );
DECL_CONV_STUB( IfcBoundedSurface );
DECL_CONV_STUB( IfcBSplineSurface );
DECL_CONV_STUB( IfcBSplineSurfaceWithKnots );
DECL_CONV_STUB( IfcBuildingElement );
DECL_CONV_STUB( IfcBeam );
DECL_CONV_STUB( IfcBeamStandardCase );
DECL_CONV_STUB( IfcBuildingElementType );
DECL_CONV_STUB( IfcBeamType );
DECL_CONV_STUB( IfcPresentationItem );
DECL_CONV_STUB( IfcCsgPrimitive3D );
DECL_CONV_STUB( IfcBlock );
DECL_CONV_STUB( IfcBoiler );
DECL_CONV_STUB( IfcBoilerType );
DECL_CONV_STUB( IfcBooleanResult );
DECL_CONV_STUB( IfcBooleanClippingResult );
DECL_CONV_STUB( IfcCompositeCurve );
DECL_CONV_STUB( IfcCompositeCurveOnSurface );
DECL_CONV_STUB( IfcBoundaryCurve );
DECL_CONV_STUB( IfcBoundingBox );
DECL_CONV_STUB( IfcHalfSpaceSolid );
DECL_CONV_STUB( IfcBoxedHalfSpace );
DECL_CONV_STUB( IfcSpatialElement );
DECL_CONV_STUB( IfcSpatialStructureElement );
DECL_CONV_STUB( IfcBuilding );
DECL_CONV_STUB( IfcElementComponent );
DECL_CONV_STUB( IfcBuildingElementPart );
DECL_CONV_STUB( IfcElementComponentType );
DECL_CONV_STUB( IfcBuildingElementPartType );
DECL_CONV_STUB( IfcBuildingElementProxy );
DECL_CONV_STUB( IfcBuildingElementProxyType );
DECL_CONV_STUB( IfcBuildingStorey );
DECL_CONV_STUB( IfcSystem );
DECL_CONV_STUB( IfcBuildingSystem );
DECL_CONV_STUB( IfcBurner );
DECL_CONV_STUB( IfcBurnerType );
DECL_CONV_STUB( IfcCShapeProfileDef );
DECL_CONV_STUB( IfcFlowFitting );
DECL_CONV_STUB( IfcCableCarrierFitting );
DECL_CONV_STUB( IfcFlowFittingType );
DECL_CONV_STUB( IfcCableCarrierFittingType );
DECL_CONV_STUB( IfcFlowSegment );
DECL_CONV_STUB( IfcCableCarrierSegment );
DECL_CONV_STUB( IfcFlowSegmentType );
DECL_CONV_STUB( IfcCableCarrierSegmentType );
DECL_CONV_STUB( IfcCableFitting );
DECL_CONV_STUB( IfcCableFittingType );
DECL_CONV_STUB( IfcCableSegment );
DECL_CONV_STUB( IfcCableSegmentType );
DECL_CONV_STUB( IfcPoint );
DECL_CONV_STUB( IfcCartesianPoint );
DECL_CONV_STUB( IfcCartesianPointList );
DECL_CONV_STUB( IfcCartesianPointList2D );
DECL_CONV_STUB( IfcCartesianPointList3D );
DECL_CONV_STUB( IfcCartesianTransformationOperator );
DECL_CONV_STUB( IfcCartesianTransformationOperator2D );
DECL_CONV_STUB( IfcCartesianTransformationOperator2DnonUniform );
DECL_CONV_STUB( IfcCartesianTransformationOperator3D );
DECL_CONV_STUB( IfcCartesianTransformationOperator3DnonUniform );
DECL_CONV_STUB( IfcCenterLineProfileDef );
DECL_CONV_STUB( IfcChiller );
DECL_CONV_STUB( IfcChillerType );
DECL_CONV_STUB( IfcChimney );
DECL_CONV_STUB( IfcChimneyType );
DECL_CONV_STUB( IfcConic );
DECL_CONV_STUB( IfcCircle );
DECL_CONV_STUB( IfcCircleProfileDef );
DECL_CONV_STUB( IfcCircleHollowProfileDef );
DECL_CONV_STUB( IfcCivilElement );
DECL_CONV_STUB( IfcCivilElementType );
DECL_CONV_STUB( IfcConnectedFaceSet );
DECL_CONV_STUB( IfcClosedShell );
DECL_CONV_STUB( IfcCoil );
DECL_CONV_STUB( IfcCoilType );
DECL_CONV_STUB( IfcColourSpecification );
DECL_CONV_STUB( IfcColourRgb );
DECL_CONV_STUB( IfcColumn );
DECL_CONV_STUB( IfcColumnStandardCase );
DECL_CONV_STUB( IfcColumnType );
DECL_CONV_STUB( IfcCommunicationsAppliance );
DECL_CONV_STUB( IfcCommunicationsApplianceType );
DECL_CONV_STUB( IfcPropertyAbstraction );
DECL_CONV_STUB( IfcProperty );
DECL_CONV_STUB( IfcComplexProperty );
DECL_CONV_STUB( IfcPropertyDefinition );
DECL_CONV_STUB( IfcCompositeCurveSegment );
DECL_CONV_STUB( IfcCompositeProfileDef );
DECL_CONV_STUB( IfcFlowMovingDevice );
DECL_CONV_STUB( IfcCompressor );
DECL_CONV_STUB( IfcFlowMovingDeviceType );
DECL_CONV_STUB( IfcCompressorType );
DECL_CONV_STUB( IfcCondenser );
DECL_CONV_STUB( IfcCondenserType );
DECL_CONV_STUB( IfcResource );
DECL_CONV_STUB( IfcConstructionResource );
DECL_CONV_STUB( IfcConstructionEquipmentResource );
DECL_CONV_STUB( IfcTypeResource );
DECL_CONV_STUB( IfcConstructionResourceType );
DECL_CONV_STUB( IfcConstructionEquipmentResourceType );
DECL_CONV_STUB( IfcConstructionMaterialResource );
DECL_CONV_STUB( IfcConstructionMaterialResourceType );
DECL_CONV_STUB( IfcConstructionProductResource );
DECL_CONV_STUB( IfcConstructionProductResourceType );
DECL_CONV_STUB( IfcContext );
DECL_CONV_STUB( IfcNamedUnit );
DECL_CONV_STUB( IfcContextDependentUnit );
DECL_CONV_STUB( IfcController );
DECL_CONV_STUB( IfcControllerType );
DECL_CONV_STUB( IfcConversionBasedUnit );
DECL_CONV_STUB( IfcConversionBasedUnitWithOffset );
DECL_CONV_STUB( IfcCooledBeam );
DECL_CONV_STUB( IfcCooledBeamType );
DECL_CONV_STUB( IfcCoolingTower );
DECL_CONV_STUB( IfcCoolingTowerType );
DECL_CONV_STUB( IfcCostItem );
DECL_CONV_STUB( IfcCostSchedule );
DECL_CONV_STUB( IfcCovering );
DECL_CONV_STUB( IfcCoveringType );
DECL_CONV_STUB( IfcCrewResource );
DECL_CONV_STUB( IfcCrewResourceType );
DECL_CONV_STUB( IfcCsgSolid );
DECL_CONV_STUB( IfcCurtainWall );
DECL_CONV_STUB( IfcCurtainWallType );
DECL_CONV_STUB( IfcCurveBoundedPlane );
DECL_CONV_STUB( IfcCurveBoundedSurface );
DECL_CONV_STUB( IfcPresentationStyle );
DECL_CONV_STUB( IfcElementarySurface );
DECL_CONV_STUB( IfcCylindricalSurface );
DECL_CONV_STUB( IfcDamper );
DECL_CONV_STUB( IfcDamperType );
DECL_CONV_STUB( IfcDerivedProfileDef );
DECL_CONV_STUB( IfcDirection );
DECL_CONV_STUB( IfcDiscreteAccessory );
DECL_CONV_STUB( IfcDiscreteAccessoryType );
DECL_CONV_STUB( IfcDistributionChamberElement );
DECL_CONV_STUB( IfcDistributionChamberElementType );
DECL_CONV_STUB( IfcDistributionSystem );
DECL_CONV_STUB( IfcDistributionCircuit );
DECL_CONV_STUB( IfcPort );
DECL_CONV_STUB( IfcDistributionPort );
DECL_CONV_STUB( IfcDoor );
DECL_CONV_STUB( IfcPropertySetDefinition );
DECL_CONV_STUB( IfcDoorStandardCase );
DECL_CONV_STUB( IfcDoorStyle );
DECL_CONV_STUB( IfcDoorType );
DECL_CONV_STUB( IfcDuctFitting );
DECL_CONV_STUB( IfcDuctFittingType );
DECL_CONV_STUB( IfcDuctSegment );
DECL_CONV_STUB( IfcDuctSegmentType );
DECL_CONV_STUB( IfcFlowTreatmentDevice );
DECL_CONV_STUB( IfcDuctSilencer );
DECL_CONV_STUB( IfcFlowTreatmentDeviceType );
DECL_CONV_STUB( IfcDuctSilencerType );
DECL_CONV_STUB( IfcEdge );
DECL_CONV_STUB( IfcEdgeCurve );
DECL_CONV_STUB( IfcLoop );
DECL_CONV_STUB( IfcEdgeLoop );
DECL_CONV_STUB( IfcElectricAppliance );
DECL_CONV_STUB( IfcElectricApplianceType );
DECL_CONV_STUB( IfcElectricDistributionBoard );
DECL_CONV_STUB( IfcElectricDistributionBoardType );
DECL_CONV_STUB( IfcFlowStorageDevice );
DECL_CONV_STUB( IfcElectricFlowStorageDevice );
DECL_CONV_STUB( IfcFlowStorageDeviceType );
DECL_CONV_STUB( IfcElectricFlowStorageDeviceType );
DECL_CONV_STUB( IfcElectricGenerator );
DECL_CONV_STUB( IfcElectricGeneratorType );
DECL_CONV_STUB( IfcElectricMotor );
DECL_CONV_STUB( IfcElectricMotorType );
DECL_CONV_STUB( IfcElectricTimeControl );
DECL_CONV_STUB( IfcElectricTimeControlType );
DECL_CONV_STUB( IfcElementAssembly );
DECL_CONV_STUB( IfcElementAssemblyType );
DECL_CONV_STUB( IfcQuantitySet );
DECL_CONV_STUB( IfcElementQuantity );
DECL_CONV_STUB( IfcEllipse );
DECL_CONV_STUB( IfcEllipseProfileDef );
DECL_CONV_STUB( IfcEngine );
DECL_CONV_STUB( IfcEngineType );
DECL_CONV_STUB( IfcEvaporativeCooler );
DECL_CONV_STUB( IfcEvaporativeCoolerType );
DECL_CONV_STUB( IfcEvaporator );
DECL_CONV_STUB( IfcEvaporatorType );
DECL_CONV_STUB( IfcProcess );
DECL_CONV_STUB( IfcEvent );
DECL_CONV_STUB( IfcTypeProcess );
DECL_CONV_STUB( IfcEventType );
DECL_CONV_STUB( IfcExternalSpatialStructureElement );
DECL_CONV_STUB( IfcExternalSpatialElement );
DECL_CONV_STUB( IfcSweptAreaSolid );
DECL_CONV_STUB( IfcExtrudedAreaSolid );
DECL_CONV_STUB( IfcExtrudedAreaSolidTapered );
DECL_CONV_STUB( IfcFaceBasedSurfaceModel );
DECL_CONV_STUB( IfcFaceBound );
DECL_CONV_STUB( IfcFaceOuterBound );
DECL_CONV_STUB( IfcFacetedBrep );
DECL_CONV_STUB( IfcFacetedBrepWithVoids );
DECL_CONV_STUB( IfcFan );
DECL_CONV_STUB( IfcFanType );
DECL_CONV_STUB( IfcFastener );
DECL_CONV_STUB( IfcFastenerType );
DECL_CONV_STUB( IfcFeatureElement );
DECL_CONV_STUB( IfcFeatureElementAddition );
DECL_CONV_STUB( IfcFeatureElementSubtraction );
DECL_CONV_STUB( IfcFillAreaStyleHatching );
DECL_CONV_STUB( IfcFillAreaStyleTiles );
DECL_CONV_STUB( IfcFilter );
DECL_CONV_STUB( IfcFilterType );
DECL_CONV_STUB( IfcFireSuppressionTerminal );
DECL_CONV_STUB( IfcFireSuppressionTerminalType );
DECL_CONV_STUB( IfcFixedReferenceSweptAreaSolid );
DECL_CONV_STUB( IfcFlowInstrument );
DECL_CONV_STUB( IfcFlowInstrumentType );
DECL_CONV_STUB( IfcFlowMeter );
DECL_CONV_STUB( IfcFlowMeterType );
DECL_CONV_STUB( IfcFooting );
DECL_CONV_STUB( IfcFootingType );
DECL_CONV_STUB( IfcFurnishingElement );
DECL_CONV_STUB( IfcFurnishingElementType );
DECL_CONV_STUB( IfcFurniture );
DECL_CONV_STUB( IfcFurnitureType );
DECL_CONV_STUB( IfcGeographicElement );
DECL_CONV_STUB( IfcGeographicElementType );
DECL_CONV_STUB( IfcGeometricSet );
DECL_CONV_STUB( IfcGeometricCurveSet );
DECL_CONV_STUB( IfcRepresentationContext );
DECL_CONV_STUB( IfcGeometricRepresentationContext );
DECL_CONV_STUB( IfcGeometricRepresentationSubContext );
DECL_CONV_STUB( IfcGrid );
DECL_CONV_STUB( IfcObjectPlacement );
DECL_CONV_STUB( IfcGridPlacement );
DECL_CONV_STUB( IfcHeatExchanger );
DECL_CONV_STUB( IfcHeatExchangerType );
DECL_CONV_STUB( IfcHumidifier );
DECL_CONV_STUB( IfcHumidifierType );
DECL_CONV_STUB( IfcIShapeProfileDef );
DECL_CONV_STUB( IfcIndexedPolyCurve );
DECL_CONV_STUB( IfcTessellatedItem );
DECL_CONV_STUB( IfcIndexedPolygonalFace );
DECL_CONV_STUB( IfcIndexedPolygonalFaceWithVoids );
DECL_CONV_STUB( IfcInterceptor );
DECL_CONV_STUB( IfcInterceptorType );
DECL_CONV_STUB( IfcSurfaceCurve );
DECL_CONV_STUB( IfcIntersectionCurve );
DECL_CONV_STUB( IfcInventory );
DECL_CONV_STUB( IfcJunctionBox );
DECL_CONV_STUB( IfcJunctionBoxType );
DECL_CONV_STUB( IfcLShapeProfileDef );
DECL_CONV_STUB( IfcLaborResource );
DECL_CONV_STUB( IfcLaborResourceType );
DECL_CONV_STUB( IfcLamp );
DECL_CONV_STUB( IfcLampType );
DECL_CONV_STUB( IfcLightFixture );
DECL_CONV_STUB( IfcLightFixtureType );
DECL_CONV_STUB( IfcLightSource );
DECL_CONV_STUB( IfcLightSourceAmbient );
DECL_CONV_STUB( IfcLightSourceDirectional );
DECL_CONV_STUB( IfcLightSourceGoniometric );
DECL_CONV_STUB( IfcLightSourcePositional );
DECL_CONV_STUB( IfcLightSourceSpot );
DECL_CONV_STUB( IfcLine );
DECL_CONV_STUB( IfcLocalPlacement );
DECL_CONV_STUB( IfcMappedItem );
DECL_CONV_STUB( IfcProductRepresentation );
DECL_CONV_STUB( IfcMaterialDefinitionRepresentation );
DECL_CONV_STUB( IfcMeasureWithUnit );
DECL_CONV_STUB( IfcMechanicalFastener );
DECL_CONV_STUB( IfcMechanicalFastenerType );
DECL_CONV_STUB( IfcMedicalDevice );
DECL_CONV_STUB( IfcMedicalDeviceType );
DECL_CONV_STUB( IfcMember );
DECL_CONV_STUB( IfcMemberStandardCase );
DECL_CONV_STUB( IfcMemberType );
DECL_CONV_STUB( IfcMirroredProfileDef );
DECL_CONV_STUB( IfcMotorConnection );
DECL_CONV_STUB( IfcMotorConnectionType );
DECL_CONV_STUB( IfcOccupant );
DECL_CONV_STUB( IfcOffsetCurve2D );
DECL_CONV_STUB( IfcOffsetCurve3D );
DECL_CONV_STUB( IfcOpenShell );
DECL_CONV_STUB( IfcOpeningElement );
DECL_CONV_STUB( IfcOpeningStandardCase );
DECL_CONV_STUB( IfcOrientedEdge );
DECL_CONV_STUB( IfcOuterBoundaryCurve );
DECL_CONV_STUB( IfcOutlet );
DECL_CONV_STUB( IfcOutletType );
DECL_CONV_STUB( IfcPath );
DECL_CONV_STUB( IfcPcurve );
DECL_CONV_STUB( IfcPerformanceHistory );
DECL_CONV_STUB( IfcPermit );
DECL_CONV_STUB( IfcPile );
DECL_CONV_STUB( IfcPileType );
DECL_CONV_STUB( IfcPipeFitting );
DECL_CONV_STUB( IfcPipeFittingType );
DECL_CONV_STUB( IfcPipeSegment );
DECL_CONV_STUB( IfcPipeSegmentType );
DECL_CONV_STUB( IfcPlanarExtent );
DECL_CONV_STUB( IfcPlanarBox );
DECL_CONV_STUB( IfcPlane );
DECL_CONV_STUB( IfcPlate );
DECL_CONV_STUB( IfcPlateStandardCase );
DECL_CONV_STUB( IfcPlateType );
DECL_CONV_STUB( IfcPointOnCurve );
DECL_CONV_STUB( IfcPointOnSurface );
DECL_CONV_STUB( IfcPolyLoop );
DECL_CONV_STUB( IfcPolygonalBoundedHalfSpace );
DECL_CONV_STUB( IfcTessellatedFaceSet );
DECL_CONV_STUB( IfcPolygonalFaceSet );
DECL_CONV_STUB( IfcPolyline );
DECL_CONV_STUB( IfcPresentationStyleAssignment );
DECL_CONV_STUB( IfcProcedure );
DECL_CONV_STUB( IfcProcedureType );
DECL_CONV_STUB( IfcProductDefinitionShape );
DECL_CONV_STUB( IfcProject );
DECL_CONV_STUB( IfcProjectLibrary );
DECL_CONV_STUB( IfcProjectOrder );
DECL_CONV_STUB( IfcProjectionElement );
DECL_CONV_STUB( IfcSimpleProperty );
DECL_CONV_STUB( IfcPropertyBoundedValue );
DECL_CONV_STUB( IfcPropertyEnumeratedValue );
DECL_CONV_STUB( IfcPropertyListValue );
DECL_CONV_STUB( IfcPropertyReferenceValue );
DECL_CONV_STUB( IfcPropertySet );
DECL_CONV_STUB( IfcPropertySingleValue );
DECL_CONV_STUB( IfcPropertyTableValue );
DECL_CONV_STUB( IfcProtectiveDevice );
DECL_CONV_STUB( IfcProtectiveDeviceTrippingUnit );
DECL_CONV_STUB( IfcProtectiveDeviceTrippingUnitType );
DECL_CONV_STUB( IfcProtectiveDeviceType );
DECL_CONV_STUB( IfcProxy );
DECL_CONV_STUB( IfcPump );
DECL_CONV_STUB( IfcPumpType );
DECL_CONV_STUB( IfcRailing );
DECL_CONV_STUB( IfcRailingType );
DECL_CONV_STUB( IfcRamp );
DECL_CONV_STUB( IfcRampFlight );
DECL_CONV_STUB( IfcRampFlightType );
DECL_CONV_STUB( IfcRampType );
DECL_CONV_STUB( IfcRationalBSplineCurveWithKnots );
DECL_CONV_STUB( IfcRationalBSplineSurfaceWithKnots );
DECL_CONV_STUB( IfcRectangleProfileDef );
DECL_CONV_STUB( IfcRectangleHollowProfileDef );
DECL_CONV_STUB( IfcRectangularPyramid );
DECL_CONV_STUB( IfcRectangularTrimmedSurface );
DECL_CONV_STUB( IfcReinforcingElement );
DECL_CONV_STUB( IfcReinforcingBar );
DECL_CONV_STUB( IfcReinforcingElementType );
DECL_CONV_STUB( IfcReinforcingBarType );
DECL_CONV_STUB( IfcReinforcingMesh );
DECL_CONV_STUB( IfcReinforcingMeshType );
DECL_CONV_STUB( IfcRelationship );
DECL_CONV_STUB( IfcRelDecomposes );
DECL_CONV_STUB( IfcRelAggregates );
DECL_CONV_STUB( IfcRelConnects );
DECL_CONV_STUB( IfcRelContainedInSpatialStructure );
DECL_CONV_STUB( IfcRelDefines );
DECL_CONV_STUB( IfcRelDefinesByProperties );
DECL_CONV_STUB( IfcRelFillsElement );
DECL_CONV_STUB( IfcRelVoidsElement );
DECL_CONV_STUB( IfcReparametrisedCompositeCurveSegment );
DECL_CONV_STUB( IfcRepresentation );
DECL_CONV_STUB( IfcRepresentationMap );
DECL_CONV_STUB( IfcRevolvedAreaSolid );
DECL_CONV_STUB( IfcRevolvedAreaSolidTapered );
DECL_CONV_STUB( IfcRightCircularCone );
DECL_CONV_STUB( IfcRightCircularCylinder );
DECL_CONV_STUB( IfcRoof );
DECL_CONV_STUB( IfcRoofType );
DECL_CONV_STUB( IfcRoundedRectangleProfileDef );
DECL_CONV_STUB( IfcSIUnit );
DECL_CONV_STUB( IfcSanitaryTerminal );
DECL_CONV_STUB( IfcSanitaryTerminalType );
DECL_CONV_STUB( IfcSeamCurve );
DECL_CONV_STUB( IfcSectionedSpine );
DECL_CONV_STUB( IfcSensor );
DECL_CONV_STUB( IfcSensorType );
DECL_CONV_STUB( IfcShadingDevice );
DECL_CONV_STUB( IfcShadingDeviceType );
DECL_CONV_STUB( IfcShapeModel );
DECL_CONV_STUB( IfcShapeRepresentation );
DECL_CONV_STUB( IfcShellBasedSurfaceModel );
DECL_CONV_STUB( IfcSite );
DECL_CONV_STUB( IfcSlab );
DECL_CONV_STUB( IfcSlabElementedCase );
DECL_CONV_STUB( IfcSlabStandardCase );
DECL_CONV_STUB( IfcSlabType );
DECL_CONV_STUB( IfcSolarDevice );
DECL_CONV_STUB( IfcSolarDeviceType );
DECL_CONV_STUB( IfcSpace );
DECL_CONV_STUB( IfcSpaceHeater );
DECL_CONV_STUB( IfcSpaceHeaterType );
DECL_CONV_STUB( IfcSpatialElementType );
DECL_CONV_STUB( IfcSpatialStructureElementType );
DECL_CONV_STUB( IfcSpaceType );
DECL_CONV_STUB( IfcSpatialZone );
DECL_CONV_STUB( IfcSpatialZoneType );
DECL_CONV_STUB( IfcSphere );
DECL_CONV_STUB( IfcSphericalSurface );
DECL_CONV_STUB( IfcStackTerminal );
DECL_CONV_STUB( IfcStackTerminalType );
DECL_CONV_STUB( IfcStair );
DECL_CONV_STUB( IfcStairFlight );
DECL_CONV_STUB( IfcStairFlightType );
DECL_CONV_STUB( IfcStairType );
DECL_CONV_STUB( IfcStructuralActivity );
DECL_CONV_STUB( IfcStructuralAction );
DECL_CONV_STUB( IfcStructuralAnalysisModel );
DECL_CONV_STUB( IfcStructuralItem );
DECL_CONV_STUB( IfcStructuralConnection );
DECL_CONV_STUB( IfcStructuralCurveAction );
DECL_CONV_STUB( IfcStructuralCurveConnection );
DECL_CONV_STUB( IfcStructuralMember );
DECL_CONV_STUB( IfcStructuralCurveMember );
DECL_CONV_STUB( IfcStructuralCurveMemberVarying );
DECL_CONV_STUB( IfcStructuralReaction );
DECL_CONV_STUB( IfcStructuralCurveReaction );
DECL_CONV_STUB( IfcStructuralLinearAction );
DECL_CONV_STUB( IfcStructuralLoadGroup );
DECL_CONV_STUB( IfcStructuralLoadCase );
DECL_CONV_STUB( IfcStructuralSurfaceAction );
DECL_CONV_STUB( IfcStructuralPlanarAction );
DECL_CONV_STUB( IfcStructuralPointAction );
DECL_CONV_STUB( IfcStructuralPointConnection );
DECL_CONV_STUB( IfcStructuralPointReaction );
DECL_CONV_STUB( IfcStructuralResultGroup );
DECL_CONV_STUB( IfcStructuralSurfaceConnection );
DECL_CONV_STUB( IfcStructuralSurfaceMember );
DECL_CONV_STUB( IfcStructuralSurfaceMemberVarying );
DECL_CONV_STUB( IfcStructuralSurfaceReaction );
DECL_CONV_STUB( IfcStyleModel );
DECL_CONV_STUB( IfcStyledItem );
DECL_CONV_STUB( IfcStyledRepresentation );
DECL_CONV_STUB( IfcSubContractResource );
DECL_CONV_STUB( IfcSubContractResourceType );
DECL_CONV_STUB( IfcSubedge );
DECL_CONV_STUB( IfcSurfaceCurveSweptAreaSolid );
DECL_CONV_STUB( IfcSurfaceFeature );
DECL_CONV_STUB( IfcSweptSurface );
DECL_CONV_STUB( IfcSurfaceOfLinearExtrusion );
DECL_CONV_STUB( IfcSurfaceOfRevolution );
DECL_CONV_STUB( IfcSurfaceStyle );
DECL_CONV_STUB( IfcSurfaceStyleShading );
DECL_CONV_STUB( IfcSurfaceStyleRendering );
DECL_CONV_STUB( IfcSurfaceStyleWithTextures );
DECL_CONV_STUB( IfcSweptDiskSolid );
DECL_CONV_STUB( IfcSweptDiskSolidPolygonal );
DECL_CONV_STUB( IfcSwitchingDevice );
DECL_CONV_STUB( IfcSwitchingDeviceType );
DECL_CONV_STUB( IfcSystemFurnitureElement );
DECL_CONV_STUB( IfcSystemFurnitureElementType );
DECL_CONV_STUB( IfcTShapeProfileDef );
DECL_CONV_STUB( IfcTank );
DECL_CONV_STUB( IfcTankType );
DECL_CONV_STUB( IfcTask );
DECL_CONV_STUB( IfcTaskType );
DECL_CONV_STUB( IfcTendon );
DECL_CONV_STUB( IfcTendonAnchor );
DECL_CONV_STUB( IfcTendonAnchorType );
DECL_CONV_STUB( IfcTendonType );
DECL_CONV_STUB( IfcTextLiteral );
DECL_CONV_STUB( IfcTextLiteralWithExtent );
DECL_CONV_STUB( IfcTopologyRepresentation );
DECL_CONV_STUB( IfcToroidalSurface );
DECL_CONV_STUB( IfcTransformer );
DECL_CONV_STUB( IfcTransformerType );
DECL_CONV_STUB( IfcTransportElement );
DECL_CONV_STUB( IfcTransportElementType );
DECL_CONV_STUB( IfcTrapeziumProfileDef );
DECL_CONV_STUB( IfcTriangulatedFaceSet );
DECL_CONV_STUB( IfcTrimmedCurve );
DECL_CONV_STUB( IfcTubeBundle );
DECL_CONV_STUB( IfcTubeBundleType );
DECL_CONV_STUB( IfcUShapeProfileDef );
DECL_CONV_STUB( IfcUnitAssignment );
DECL_CONV_STUB( IfcUnitaryControlElement );
DECL_CONV_STUB( IfcUnitaryControlElementType );
DECL_CONV_STUB( IfcUnitaryEquipment );
DECL_CONV_STUB( IfcUnitaryEquipmentType );
DECL_CONV_STUB( IfcValve );
DECL_CONV_STUB( IfcValveType );
DECL_CONV_STUB( IfcVector );
DECL_CONV_STUB( IfcVertex );
DECL_CONV_STUB( IfcVertexLoop );
DECL_CONV_STUB( IfcVertexPoint );
DECL_CONV_STUB( IfcVibrationIsolator );
DECL_CONV_STUB( IfcVibrationIsolatorType );
DECL_CONV_STUB( IfcVirtualElement );
DECL_CONV_STUB( IfcVoidingFeature );
DECL_CONV_STUB( IfcWall );
DECL_CONV_STUB( IfcWallElementedCase );
DECL_CONV_STUB( IfcWallStandardCase );
DECL_CONV_STUB( IfcWallType );
DECL_CONV_STUB( IfcWasteTerminal );
DECL_CONV_STUB( IfcWasteTerminalType );
DECL_CONV_STUB( IfcWindow );
DECL_CONV_STUB( IfcWindowStandardCase );
DECL_CONV_STUB( IfcWindowStyle );
DECL_CONV_STUB( IfcWindowType );
DECL_CONV_STUB( IfcWorkCalendar );
DECL_CONV_STUB( IfcWorkControl );
DECL_CONV_STUB( IfcWorkPlan );
DECL_CONV_STUB( IfcWorkSchedule );
DECL_CONV_STUB( IfcZShapeProfileDef );
DECL_CONV_STUB( IfcZone );
IFC: introduce new namespace fpr IFC-schema2x3
2018-01-13 09:27:45 +00:00
#undef DECL_CONV_STUB
closes https://github.com/assimp/assimp/issues/1752: move guard over include statement.
2018-02-03 07:46:03 +00:00
} //! Schema_4
IFC: introduce new namespace fpr IFC-schema2x3
2018-01-13 09:27:45 +00:00
} //! STEP
} //! Assimp
#endif // INCLUDED_IFC_READER_GEN_H