4369 lines
200 KiB
C++
4369 lines
200 KiB
C++
/*
|
|
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 {
|
|
using namespace STEP;
|
|
using namespace STEP::EXPRESS;
|
|
|
|
|
|
struct NotImplemented : public ObjectHelper<NotImplemented,0> {
|
|
|
|
};
|
|
|
|
|
|
// ******************************************************************************
|
|
// IFC Custom data types
|
|
// ******************************************************************************
|
|
|
|
|
|
// 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 IfcAreaMeasure
|
|
typedef REAL IfcAreaMeasure;
|
|
// C++ wrapper type for IfcBoolean
|
|
typedef BOOLEAN IfcBoolean;
|
|
// C++ wrapper type for IfcBoxAlignment
|
|
typedef STRING IfcBoxAlignment;
|
|
// C++ wrapper type for IfcCompoundPlaneAngleMeasure
|
|
typedef ListOf< INTEGER, 3, 3 > 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 IfcDayInMonthNumber
|
|
typedef INTEGER IfcDayInMonthNumber;
|
|
// C++ wrapper type for IfcDaylightSavingHour
|
|
typedef INTEGER IfcDaylightSavingHour;
|
|
// 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 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 IfcHourInDay
|
|
typedef INTEGER IfcHourInDay;
|
|
// 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 IfcLengthMeasure
|
|
typedef REAL IfcLengthMeasure;
|
|
// 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 IfcMinuteInHour
|
|
typedef INTEGER IfcMinuteInHour;
|
|
// 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 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 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 IfcSecondInMinute
|
|
typedef REAL IfcSecondInMinute;
|
|
// 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 IfcSoundPowerMeasure
|
|
typedef REAL IfcSoundPowerMeasure;
|
|
// 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 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 IfcTimeMeasure
|
|
typedef REAL IfcTimeMeasure;
|
|
// C++ wrapper type for IfcTimeStamp
|
|
typedef INTEGER IfcTimeStamp;
|
|
// C++ wrapper type for IfcTorqueMeasure
|
|
typedef REAL IfcTorqueMeasure;
|
|
// 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 IfcYearNumber
|
|
typedef INTEGER IfcYearNumber;
|
|
// 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 IfcAheadOrBehind
|
|
typedef ENUMERATION IfcAheadOrBehind;
|
|
// 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 IfcBSplineCurveForm
|
|
typedef ENUMERATION IfcBSplineCurveForm;
|
|
// 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 IfcBuildingElementProxyTypeEnum
|
|
typedef ENUMERATION IfcBuildingElementProxyTypeEnum;
|
|
// C++ wrapper type for IfcCableCarrierFittingTypeEnum
|
|
typedef ENUMERATION IfcCableCarrierFittingTypeEnum;
|
|
// C++ wrapper type for IfcCableCarrierSegmentTypeEnum
|
|
typedef ENUMERATION IfcCableCarrierSegmentTypeEnum;
|
|
// 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 IfcCoilTypeEnum
|
|
typedef ENUMERATION IfcCoilTypeEnum;
|
|
// C++ wrapper type for IfcColumnTypeEnum
|
|
typedef ENUMERATION IfcColumnTypeEnum;
|
|
// 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 IfcControllerTypeEnum
|
|
typedef ENUMERATION IfcControllerTypeEnum;
|
|
// C++ wrapper type for IfcCooledBeamTypeEnum
|
|
typedef ENUMERATION IfcCooledBeamTypeEnum;
|
|
// C++ wrapper type for IfcCoolingTowerTypeEnum
|
|
typedef ENUMERATION IfcCoolingTowerTypeEnum;
|
|
// C++ wrapper type for IfcCostScheduleTypeEnum
|
|
typedef ENUMERATION IfcCostScheduleTypeEnum;
|
|
// C++ wrapper type for IfcCoveringTypeEnum
|
|
typedef ENUMERATION IfcCoveringTypeEnum;
|
|
// C++ wrapper type for IfcCurrencyEnum
|
|
typedef ENUMERATION IfcCurrencyEnum;
|
|
// C++ wrapper type for IfcCurtainWallTypeEnum
|
|
typedef ENUMERATION IfcCurtainWallTypeEnum;
|
|
// 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 IfcDimensionExtentUsage
|
|
typedef ENUMERATION IfcDimensionExtentUsage;
|
|
// C++ wrapper type for IfcDirectionSenseEnum
|
|
typedef ENUMERATION IfcDirectionSenseEnum;
|
|
// C++ wrapper type for IfcDistributionChamberElementTypeEnum
|
|
typedef ENUMERATION IfcDistributionChamberElementTypeEnum;
|
|
// 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 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 IfcElectricCurrentEnum
|
|
typedef ENUMERATION IfcElectricCurrentEnum;
|
|
// C++ wrapper type for IfcElectricDistributionPointFunctionEnum
|
|
typedef ENUMERATION IfcElectricDistributionPointFunctionEnum;
|
|
// C++ wrapper type for IfcElectricFlowStorageDeviceTypeEnum
|
|
typedef ENUMERATION IfcElectricFlowStorageDeviceTypeEnum;
|
|
// C++ wrapper type for IfcElectricGeneratorTypeEnum
|
|
typedef ENUMERATION IfcElectricGeneratorTypeEnum;
|
|
// C++ wrapper type for IfcElectricHeaterTypeEnum
|
|
typedef ENUMERATION IfcElectricHeaterTypeEnum;
|
|
// 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 IfcEnergySequenceEnum
|
|
typedef ENUMERATION IfcEnergySequenceEnum;
|
|
// C++ wrapper type for IfcEnvironmentalImpactCategoryEnum
|
|
typedef ENUMERATION IfcEnvironmentalImpactCategoryEnum;
|
|
// C++ wrapper type for IfcEvaporativeCoolerTypeEnum
|
|
typedef ENUMERATION IfcEvaporativeCoolerTypeEnum;
|
|
// C++ wrapper type for IfcEvaporatorTypeEnum
|
|
typedef ENUMERATION IfcEvaporatorTypeEnum;
|
|
// C++ wrapper type for IfcFanTypeEnum
|
|
typedef ENUMERATION IfcFanTypeEnum;
|
|
// 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 IfcGasTerminalTypeEnum
|
|
typedef ENUMERATION IfcGasTerminalTypeEnum;
|
|
// C++ wrapper type for IfcGeometricProjectionEnum
|
|
typedef ENUMERATION IfcGeometricProjectionEnum;
|
|
// C++ wrapper type for IfcGlobalOrLocalEnum
|
|
typedef ENUMERATION IfcGlobalOrLocalEnum;
|
|
// C++ wrapper type for IfcHeatExchangerTypeEnum
|
|
typedef ENUMERATION IfcHeatExchangerTypeEnum;
|
|
// C++ wrapper type for IfcHumidifierTypeEnum
|
|
typedef ENUMERATION IfcHumidifierTypeEnum;
|
|
// 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 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 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 IfcOutletTypeEnum
|
|
typedef ENUMERATION IfcOutletTypeEnum;
|
|
// C++ wrapper type for IfcPermeableCoveringOperationEnum
|
|
typedef ENUMERATION IfcPermeableCoveringOperationEnum;
|
|
// 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 IfcProcedureTypeEnum
|
|
typedef ENUMERATION IfcProcedureTypeEnum;
|
|
// C++ wrapper type for IfcProfileTypeEnum
|
|
typedef ENUMERATION IfcProfileTypeEnum;
|
|
// C++ wrapper type for IfcProjectOrderRecordTypeEnum
|
|
typedef ENUMERATION IfcProjectOrderRecordTypeEnum;
|
|
// C++ wrapper type for IfcProjectOrderTypeEnum
|
|
typedef ENUMERATION IfcProjectOrderTypeEnum;
|
|
// C++ wrapper type for IfcProjectedOrTrueLengthEnum
|
|
typedef ENUMERATION IfcProjectedOrTrueLengthEnum;
|
|
// C++ wrapper type for IfcPropertySourceEnum
|
|
typedef ENUMERATION IfcPropertySourceEnum;
|
|
// 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 IfcReflectanceMethodEnum
|
|
typedef ENUMERATION IfcReflectanceMethodEnum;
|
|
// C++ wrapper type for IfcReinforcingBarRoleEnum
|
|
typedef ENUMERATION IfcReinforcingBarRoleEnum;
|
|
// C++ wrapper type for IfcReinforcingBarSurfaceEnum
|
|
typedef ENUMERATION IfcReinforcingBarSurfaceEnum;
|
|
// C++ wrapper type for IfcResourceConsumptionEnum
|
|
typedef ENUMERATION IfcResourceConsumptionEnum;
|
|
// C++ wrapper type for IfcRibPlateDirectionEnum
|
|
typedef ENUMERATION IfcRibPlateDirectionEnum;
|
|
// 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 IfcServiceLifeFactorTypeEnum
|
|
typedef ENUMERATION IfcServiceLifeFactorTypeEnum;
|
|
// C++ wrapper type for IfcServiceLifeTypeEnum
|
|
typedef ENUMERATION IfcServiceLifeTypeEnum;
|
|
// C++ wrapper type for IfcSlabTypeEnum
|
|
typedef ENUMERATION IfcSlabTypeEnum;
|
|
// C++ wrapper type for IfcSoundScaleEnum
|
|
typedef ENUMERATION IfcSoundScaleEnum;
|
|
// C++ wrapper type for IfcSpaceHeaterTypeEnum
|
|
typedef ENUMERATION IfcSpaceHeaterTypeEnum;
|
|
// C++ wrapper type for IfcSpaceTypeEnum
|
|
typedef ENUMERATION IfcSpaceTypeEnum;
|
|
// 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 IfcStructuralCurveTypeEnum
|
|
typedef ENUMERATION IfcStructuralCurveTypeEnum;
|
|
// C++ wrapper type for IfcStructuralSurfaceTypeEnum
|
|
typedef ENUMERATION IfcStructuralSurfaceTypeEnum;
|
|
// C++ wrapper type for IfcSurfaceSide
|
|
typedef ENUMERATION IfcSurfaceSide;
|
|
// C++ wrapper type for IfcSurfaceTextureEnum
|
|
typedef ENUMERATION IfcSurfaceTextureEnum;
|
|
// C++ wrapper type for IfcSwitchingDeviceTypeEnum
|
|
typedef ENUMERATION IfcSwitchingDeviceTypeEnum;
|
|
// C++ wrapper type for IfcTankTypeEnum
|
|
typedef ENUMERATION IfcTankTypeEnum;
|
|
// C++ wrapper type for IfcTendonTypeEnum
|
|
typedef ENUMERATION IfcTendonTypeEnum;
|
|
// C++ wrapper type for IfcTextPath
|
|
typedef ENUMERATION IfcTextPath;
|
|
// C++ wrapper type for IfcThermalLoadSourceEnum
|
|
typedef ENUMERATION IfcThermalLoadSourceEnum;
|
|
// C++ wrapper type for IfcThermalLoadTypeEnum
|
|
typedef ENUMERATION IfcThermalLoadTypeEnum;
|
|
// C++ wrapper type for IfcTimeSeriesDataTypeEnum
|
|
typedef ENUMERATION IfcTimeSeriesDataTypeEnum;
|
|
// C++ wrapper type for IfcTimeSeriesScheduleTypeEnum
|
|
typedef ENUMERATION IfcTimeSeriesScheduleTypeEnum;
|
|
// 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 IfcUnitaryEquipmentTypeEnum
|
|
typedef ENUMERATION IfcUnitaryEquipmentTypeEnum;
|
|
// C++ wrapper type for IfcValveTypeEnum
|
|
typedef ENUMERATION IfcValveTypeEnum;
|
|
// C++ wrapper type for IfcVibrationIsolatorTypeEnum
|
|
typedef ENUMERATION IfcVibrationIsolatorTypeEnum;
|
|
// 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 IfcWorkControlTypeEnum
|
|
typedef ENUMERATION IfcWorkControlTypeEnum;
|
|
// 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 IfcBooleanOperand
|
|
typedef SELECT IfcBooleanOperand;
|
|
// C++ wrapper type for IfcCharacterStyleSelect
|
|
typedef SELECT IfcCharacterStyleSelect;
|
|
// C++ wrapper type for IfcClassificationNotationSelect
|
|
typedef SELECT IfcClassificationNotationSelect;
|
|
// C++ wrapper type for IfcColour
|
|
typedef SELECT IfcColour;
|
|
// C++ wrapper type for IfcColourOrFactor
|
|
typedef SELECT IfcColourOrFactor;
|
|
// C++ wrapper type for IfcConditionCriterionSelect
|
|
typedef SELECT IfcConditionCriterionSelect;
|
|
// C++ wrapper type for IfcCsgSelect
|
|
typedef SELECT IfcCsgSelect;
|
|
// C++ wrapper type for IfcCurveFontOrScaledCurveFontSelect
|
|
typedef SELECT IfcCurveFontOrScaledCurveFontSelect;
|
|
// C++ wrapper type for IfcCurveOrEdgeCurve
|
|
typedef SELECT IfcCurveOrEdgeCurve;
|
|
// C++ wrapper type for IfcCurveStyleFontSelect
|
|
typedef SELECT IfcCurveStyleFontSelect;
|
|
// C++ wrapper type for IfcDateTimeSelect
|
|
typedef SELECT IfcDateTimeSelect;
|
|
// C++ wrapper type for IfcDefinedSymbolSelect
|
|
typedef SELECT IfcDefinedSymbolSelect;
|
|
// C++ wrapper type for IfcDerivedMeasureValue
|
|
typedef SELECT IfcDerivedMeasureValue;
|
|
// C++ wrapper type for IfcDocumentSelect
|
|
typedef SELECT IfcDocumentSelect;
|
|
// C++ wrapper type for IfcDraughtingCalloutElement
|
|
typedef SELECT IfcDraughtingCalloutElement;
|
|
// C++ wrapper type for IfcFillAreaStyleTileShapeSelect
|
|
typedef SELECT IfcFillAreaStyleTileShapeSelect;
|
|
// C++ wrapper type for IfcFillStyleSelect
|
|
typedef SELECT IfcFillStyleSelect;
|
|
// C++ wrapper type for IfcGeometricSetSelect
|
|
typedef SELECT IfcGeometricSetSelect;
|
|
// 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 IfcObjectReferenceSelect
|
|
typedef SELECT IfcObjectReferenceSelect;
|
|
// C++ wrapper type for IfcOrientationSelect
|
|
typedef SELECT IfcOrientationSelect;
|
|
// C++ wrapper type for IfcPointOrVertexPoint
|
|
typedef SELECT IfcPointOrVertexPoint;
|
|
// C++ wrapper type for IfcPresentationStyleSelect
|
|
typedef SELECT IfcPresentationStyleSelect;
|
|
// 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 IfcSpecularHighlightSelect
|
|
typedef SELECT IfcSpecularHighlightSelect;
|
|
// C++ wrapper type for IfcStructuralActivityAssignmentSelect
|
|
typedef SELECT IfcStructuralActivityAssignmentSelect;
|
|
// C++ wrapper type for IfcSurfaceOrFaceSurface
|
|
typedef SELECT IfcSurfaceOrFaceSurface;
|
|
// C++ wrapper type for IfcSurfaceStyleElementSelect
|
|
typedef SELECT IfcSurfaceStyleElementSelect;
|
|
// C++ wrapper type for IfcSymbolStyleSelect
|
|
typedef SELECT IfcSymbolStyleSelect;
|
|
// C++ wrapper type for IfcTextFontSelect
|
|
typedef SELECT IfcTextFontSelect;
|
|
// C++ wrapper type for IfcTextStyleSelect
|
|
typedef SELECT IfcTextStyleSelect;
|
|
// 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;
|
|
|
|
|
|
// ******************************************************************************
|
|
// IFC Entities
|
|
// ******************************************************************************
|
|
|
|
struct IfcRepresentationItem;
|
|
struct IfcGeometricRepresentationItem;
|
|
struct IfcCurve;
|
|
struct IfcBoundedCurve;
|
|
struct IfcCompositeCurve;
|
|
struct Ifc2DCompositeCurve;
|
|
struct IfcRoot;
|
|
struct IfcObjectDefinition;
|
|
struct IfcObject;
|
|
struct IfcControl;
|
|
struct IfcActionRequest;
|
|
struct IfcActor;
|
|
typedef NotImplemented IfcActorRole; // (not currently used by Assimp)
|
|
struct IfcTypeObject;
|
|
struct IfcTypeProduct;
|
|
struct IfcElementType;
|
|
struct IfcDistributionElementType;
|
|
struct IfcDistributionControlElementType;
|
|
struct IfcActuatorType;
|
|
typedef NotImplemented IfcAddress; // (not currently used by Assimp)
|
|
struct IfcDistributionFlowElementType;
|
|
struct IfcFlowControllerType;
|
|
struct IfcAirTerminalBoxType;
|
|
struct IfcFlowTerminalType;
|
|
struct IfcAirTerminalType;
|
|
struct IfcEnergyConversionDeviceType;
|
|
struct IfcAirToAirHeatRecoveryType;
|
|
struct IfcAlarmType;
|
|
struct IfcDraughtingCallout;
|
|
struct IfcDimensionCurveDirectedCallout;
|
|
struct IfcAngularDimension;
|
|
struct IfcProduct;
|
|
struct IfcAnnotation;
|
|
struct IfcStyledItem;
|
|
struct IfcAnnotationOccurrence;
|
|
struct IfcAnnotationCurveOccurrence;
|
|
struct IfcAnnotationFillArea;
|
|
struct IfcAnnotationFillAreaOccurrence;
|
|
struct IfcAnnotationSurface;
|
|
struct IfcAnnotationSurfaceOccurrence;
|
|
struct IfcAnnotationSymbolOccurrence;
|
|
struct IfcAnnotationTextOccurrence;
|
|
typedef NotImplemented IfcApplication; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcAppliedValue; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcAppliedValueRelationship; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcApproval; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcApprovalActorRelationship; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcApprovalPropertyRelationship; // (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 IfcIShapeProfileDef;
|
|
struct IfcAsymmetricIShapeProfileDef;
|
|
struct IfcPlacement;
|
|
struct IfcAxis1Placement;
|
|
struct IfcAxis2Placement2D;
|
|
struct IfcAxis2Placement3D;
|
|
struct IfcBSplineCurve;
|
|
struct IfcElement;
|
|
struct IfcBuildingElement;
|
|
struct IfcBeam;
|
|
struct IfcBuildingElementType;
|
|
struct IfcBeamType;
|
|
struct IfcBezierCurve;
|
|
typedef NotImplemented IfcSurfaceTexture; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcBlobTexture; // (not currently used by Assimp)
|
|
struct IfcCsgPrimitive3D;
|
|
struct IfcBlock;
|
|
struct IfcBoilerType;
|
|
struct IfcBooleanResult;
|
|
struct IfcBooleanClippingResult;
|
|
typedef NotImplemented IfcBoundaryCondition; // (not currently used by Assimp)
|
|
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 IfcSurface;
|
|
struct IfcBoundedSurface;
|
|
struct IfcBoundingBox;
|
|
struct IfcHalfSpaceSolid;
|
|
struct IfcBoxedHalfSpace;
|
|
struct IfcSpatialStructureElement;
|
|
struct IfcBuilding;
|
|
struct IfcBuildingElementComponent;
|
|
struct IfcBuildingElementPart;
|
|
struct IfcBuildingElementProxy;
|
|
struct IfcBuildingElementProxyType;
|
|
struct IfcBuildingStorey;
|
|
struct IfcCShapeProfileDef;
|
|
struct IfcFlowFittingType;
|
|
struct IfcCableCarrierFittingType;
|
|
struct IfcFlowSegmentType;
|
|
struct IfcCableCarrierSegmentType;
|
|
struct IfcCableSegmentType;
|
|
typedef NotImplemented IfcCalendarDate; // (not currently used by Assimp)
|
|
struct IfcPoint;
|
|
struct IfcCartesianPoint;
|
|
struct IfcCartesianTransformationOperator;
|
|
struct IfcCartesianTransformationOperator2D;
|
|
struct IfcCartesianTransformationOperator2DnonUniform;
|
|
struct IfcCartesianTransformationOperator3D;
|
|
struct IfcCartesianTransformationOperator3DnonUniform;
|
|
struct IfcCenterLineProfileDef;
|
|
struct IfcFeatureElement;
|
|
struct IfcFeatureElementSubtraction;
|
|
struct IfcEdgeFeature;
|
|
struct IfcChamferEdgeFeature;
|
|
struct IfcChillerType;
|
|
struct IfcConic;
|
|
struct IfcCircle;
|
|
struct IfcCircleProfileDef;
|
|
struct IfcCircleHollowProfileDef;
|
|
typedef NotImplemented IfcClassification; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcClassificationItem; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcClassificationItemRelationship; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcClassificationNotation; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcClassificationNotationFacet; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcExternalReference; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcClassificationReference; // (not currently used by Assimp)
|
|
struct IfcTopologicalRepresentationItem;
|
|
struct IfcConnectedFaceSet;
|
|
struct IfcClosedShell;
|
|
struct IfcCoilType;
|
|
struct IfcColourSpecification;
|
|
struct IfcColourRgb;
|
|
struct IfcColumn;
|
|
struct IfcColumnType;
|
|
struct IfcProperty;
|
|
struct IfcComplexProperty;
|
|
struct IfcCompositeCurveSegment;
|
|
struct IfcCompositeProfileDef;
|
|
struct IfcFlowMovingDeviceType;
|
|
struct IfcCompressorType;
|
|
struct IfcCondenserType;
|
|
struct IfcCondition;
|
|
struct IfcConditionCriterion;
|
|
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 IfcConnectionPortGeometry; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcConnectionSurfaceGeometry; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcConstraint; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcConstraintAggregationRelationship; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcConstraintClassificationRelationship; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcConstraintRelationship; // (not currently used by Assimp)
|
|
struct IfcResource;
|
|
struct IfcConstructionResource;
|
|
struct IfcConstructionEquipmentResource;
|
|
struct IfcConstructionMaterialResource;
|
|
struct IfcConstructionProductResource;
|
|
struct IfcNamedUnit;
|
|
struct IfcContextDependentUnit;
|
|
struct IfcControllerType;
|
|
struct IfcConversionBasedUnit;
|
|
struct IfcCooledBeamType;
|
|
struct IfcCoolingTowerType;
|
|
typedef NotImplemented IfcCoordinatedUniversalTimeOffset; // (not currently used by Assimp)
|
|
struct IfcCostItem;
|
|
struct IfcCostSchedule;
|
|
typedef NotImplemented IfcCostValue; // (not currently used by Assimp)
|
|
struct IfcCovering;
|
|
struct IfcCoveringType;
|
|
struct IfcCraneRailAShapeProfileDef;
|
|
struct IfcCraneRailFShapeProfileDef;
|
|
struct IfcCrewResource;
|
|
struct IfcSolidModel;
|
|
struct IfcCsgSolid;
|
|
typedef NotImplemented IfcCurrencyRelationship; // (not currently used by Assimp)
|
|
struct IfcCurtainWall;
|
|
struct IfcCurtainWallType;
|
|
struct IfcCurveBoundedPlane;
|
|
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 IfcDamperType;
|
|
typedef NotImplemented IfcDateAndTime; // (not currently used by Assimp)
|
|
struct IfcDefinedSymbol;
|
|
struct IfcDerivedProfileDef;
|
|
typedef NotImplemented IfcDerivedUnit; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcDerivedUnitElement; // (not currently used by Assimp)
|
|
struct IfcDiameterDimension;
|
|
typedef NotImplemented IfcDraughtingCalloutRelationship; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcDimensionCalloutRelationship; // (not currently used by Assimp)
|
|
struct IfcDimensionCurve;
|
|
struct IfcTerminatorSymbol;
|
|
struct IfcDimensionCurveTerminator;
|
|
typedef NotImplemented IfcDimensionPair; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcDimensionalExponents; // (not currently used by Assimp)
|
|
struct IfcDirection;
|
|
struct IfcElementComponent;
|
|
struct IfcDiscreteAccessory;
|
|
struct IfcElementComponentType;
|
|
struct IfcDiscreteAccessoryType;
|
|
struct IfcDistributionElement;
|
|
struct IfcDistributionFlowElement;
|
|
struct IfcDistributionChamberElement;
|
|
struct IfcDistributionChamberElementType;
|
|
struct IfcDistributionControlElement;
|
|
struct IfcPort;
|
|
struct IfcDistributionPort;
|
|
typedef NotImplemented IfcDocumentElectronicFormat; // (not currently used by Assimp)
|
|
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 IfcPropertyDefinition;
|
|
struct IfcPropertySetDefinition;
|
|
typedef NotImplemented IfcDoorLiningProperties; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcDoorPanelProperties; // (not currently used by Assimp)
|
|
struct IfcDoorStyle;
|
|
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)
|
|
typedef NotImplemented IfcPreDefinedTextFont; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcDraughtingPreDefinedTextFont; // (not currently used by Assimp)
|
|
struct IfcDuctFittingType;
|
|
struct IfcDuctSegmentType;
|
|
struct IfcFlowTreatmentDeviceType;
|
|
struct IfcDuctSilencerType;
|
|
struct IfcEdge;
|
|
struct IfcEdgeCurve;
|
|
struct IfcLoop;
|
|
struct IfcEdgeLoop;
|
|
struct IfcElectricApplianceType;
|
|
struct IfcFlowController;
|
|
struct IfcElectricDistributionPoint;
|
|
struct IfcFlowStorageDeviceType;
|
|
struct IfcElectricFlowStorageDeviceType;
|
|
struct IfcElectricGeneratorType;
|
|
struct IfcElectricHeaterType;
|
|
struct IfcElectricMotorType;
|
|
struct IfcElectricTimeControlType;
|
|
typedef NotImplemented IfcEnergyProperties; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcElectricalBaseProperties; // (not currently used by Assimp)
|
|
struct IfcSystem;
|
|
struct IfcElectricalCircuit;
|
|
struct IfcElectricalElement;
|
|
struct IfcElementAssembly;
|
|
struct IfcElementQuantity;
|
|
struct IfcElementarySurface;
|
|
struct IfcEllipse;
|
|
struct IfcEllipseProfileDef;
|
|
struct IfcEnergyConversionDevice;
|
|
typedef NotImplemented IfcEnvironmentalImpactValue; // (not currently used by Assimp)
|
|
struct IfcEquipmentElement;
|
|
struct IfcEquipmentStandard;
|
|
struct IfcEvaporativeCoolerType;
|
|
struct IfcEvaporatorType;
|
|
typedef NotImplemented IfcMaterialProperties; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcExtendedMaterialProperties; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcExternallyDefinedHatchStyle; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcExternallyDefinedSurfaceStyle; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcExternallyDefinedSymbol; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcExternallyDefinedTextFont; // (not currently used by Assimp)
|
|
struct IfcSweptAreaSolid;
|
|
struct IfcExtrudedAreaSolid;
|
|
struct IfcFace;
|
|
struct IfcFaceBasedSurfaceModel;
|
|
struct IfcFaceBound;
|
|
struct IfcFaceOuterBound;
|
|
struct IfcFaceSurface;
|
|
struct IfcManifoldSolidBrep;
|
|
struct IfcFacetedBrep;
|
|
struct IfcFacetedBrepWithVoids;
|
|
typedef NotImplemented IfcStructuralConnectionCondition; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcFailureConnectionCondition; // (not currently used by Assimp)
|
|
struct IfcFanType;
|
|
struct IfcFastener;
|
|
struct IfcFastenerType;
|
|
struct IfcFeatureElementAddition;
|
|
typedef NotImplemented IfcFillAreaStyle; // (not currently used by Assimp)
|
|
struct IfcFillAreaStyleHatching;
|
|
struct IfcFillAreaStyleTileSymbolWithStyle;
|
|
struct IfcFillAreaStyleTiles;
|
|
struct IfcFilterType;
|
|
struct IfcFireSuppressionTerminalType;
|
|
struct IfcFlowFitting;
|
|
struct IfcFlowInstrumentType;
|
|
struct IfcFlowMeterType;
|
|
struct IfcFlowMovingDevice;
|
|
struct IfcFlowSegment;
|
|
struct IfcFlowStorageDevice;
|
|
struct IfcFlowTerminal;
|
|
struct IfcFlowTreatmentDevice;
|
|
typedef NotImplemented IfcFluidFlowProperties; // (not currently used by Assimp)
|
|
struct IfcFooting;
|
|
typedef NotImplemented IfcFuelProperties; // (not currently used by Assimp)
|
|
struct IfcFurnishingElement;
|
|
struct IfcFurnishingElementType;
|
|
struct IfcFurnitureStandard;
|
|
struct IfcFurnitureType;
|
|
struct IfcGasTerminalType;
|
|
typedef NotImplemented IfcGeneralMaterialProperties; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcProfileProperties; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcGeneralProfileProperties; // (not currently used by Assimp)
|
|
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 IfcHeatExchangerType;
|
|
struct IfcHumidifierType;
|
|
typedef NotImplemented IfcHygroscopicMaterialProperties; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcImageTexture; // (not currently used by Assimp)
|
|
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 IfcJunctionBoxType;
|
|
struct IfcLShapeProfileDef;
|
|
struct IfcLaborResource;
|
|
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 IfcLightFixtureType;
|
|
typedef NotImplemented IfcLightIntensityDistribution; // (not currently used by Assimp)
|
|
struct IfcLightSource;
|
|
struct IfcLightSourceAmbient;
|
|
struct IfcLightSourceDirectional;
|
|
struct IfcLightSourceGoniometric;
|
|
struct IfcLightSourcePositional;
|
|
struct IfcLightSourceSpot;
|
|
struct IfcLine;
|
|
struct IfcLinearDimension;
|
|
struct IfcLocalPlacement;
|
|
typedef NotImplemented IfcLocalTime; // (not currently used by Assimp)
|
|
struct IfcMappedItem;
|
|
typedef NotImplemented IfcMaterial; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcMaterialClassificationRelationship; // (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 IfcMaterialLayerSetUsage; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcMaterialList; // (not currently used by Assimp)
|
|
struct IfcMeasureWithUnit;
|
|
typedef NotImplemented IfcMechanicalMaterialProperties; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcMechanicalConcreteMaterialProperties; // (not currently used by Assimp)
|
|
struct IfcMechanicalFastener;
|
|
struct IfcMechanicalFastenerType;
|
|
typedef NotImplemented IfcMechanicalSteelMaterialProperties; // (not currently used by Assimp)
|
|
struct IfcMember;
|
|
struct IfcMemberType;
|
|
typedef NotImplemented IfcMetric; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcMonetaryUnit; // (not currently used by Assimp)
|
|
struct IfcMotorConnectionType;
|
|
struct IfcProcess;
|
|
struct IfcTask;
|
|
struct IfcMove;
|
|
typedef NotImplemented IfcObjective; // (not currently used by Assimp)
|
|
struct IfcOccupant;
|
|
struct IfcOffsetCurve2D;
|
|
struct IfcOffsetCurve3D;
|
|
struct IfcOneDirectionRepeatFactor;
|
|
struct IfcOpenShell;
|
|
struct IfcOpeningElement;
|
|
typedef NotImplemented IfcOpticalMaterialProperties; // (not currently used by Assimp)
|
|
struct IfcOrderAction;
|
|
typedef NotImplemented IfcOrganization; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcOrganizationRelationship; // (not currently used by Assimp)
|
|
struct IfcOrientedEdge;
|
|
struct IfcOutletType;
|
|
typedef NotImplemented IfcOwnerHistory; // (not currently used by Assimp)
|
|
struct IfcPath;
|
|
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 IfcPipeFittingType;
|
|
struct IfcPipeSegmentType;
|
|
typedef NotImplemented IfcPixelTexture; // (not currently used by Assimp)
|
|
struct IfcPlanarExtent;
|
|
struct IfcPlanarBox;
|
|
struct IfcPlane;
|
|
struct IfcPlate;
|
|
struct IfcPlateType;
|
|
struct IfcPointOnCurve;
|
|
struct IfcPointOnSurface;
|
|
struct IfcPolyLoop;
|
|
struct IfcPolygonalBoundedHalfSpace;
|
|
struct IfcPolyline;
|
|
typedef NotImplemented IfcPostalAddress; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcPreDefinedSymbol; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcPreDefinedDimensionSymbol; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcPreDefinedPointMarkerSymbol; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcPreDefinedTerminatorSymbol; // (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 IfcProductDefinitionShape;
|
|
typedef NotImplemented IfcProductsOfCombustionProperties; // (not currently used by Assimp)
|
|
struct IfcProject;
|
|
struct IfcProjectOrder;
|
|
struct IfcProjectOrderRecord;
|
|
struct IfcProjectionCurve;
|
|
struct IfcProjectionElement;
|
|
struct IfcSimpleProperty;
|
|
struct IfcPropertyBoundedValue;
|
|
typedef NotImplemented IfcPropertyConstraintRelationship; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcPropertyDependencyRelationship; // (not currently used by Assimp)
|
|
struct IfcPropertyEnumeratedValue;
|
|
typedef NotImplemented IfcPropertyEnumeration; // (not currently used by Assimp)
|
|
struct IfcPropertyListValue;
|
|
struct IfcPropertyReferenceValue;
|
|
struct IfcPropertySet;
|
|
struct IfcPropertySingleValue;
|
|
struct IfcPropertyTableValue;
|
|
struct IfcProtectiveDeviceType;
|
|
struct IfcProxy;
|
|
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 IfcRadiusDimension;
|
|
struct IfcRailing;
|
|
struct IfcRailingType;
|
|
struct IfcRamp;
|
|
struct IfcRampFlight;
|
|
struct IfcRampFlightType;
|
|
struct IfcRationalBezierCurve;
|
|
struct IfcRectangleProfileDef;
|
|
struct IfcRectangleHollowProfileDef;
|
|
struct IfcRectangularPyramid;
|
|
struct IfcRectangularTrimmedSurface;
|
|
typedef NotImplemented IfcReferencesValueDocument; // (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 IfcReinforcingMesh;
|
|
struct IfcRelationship;
|
|
struct IfcRelDecomposes;
|
|
struct IfcRelAggregates;
|
|
typedef NotImplemented IfcRelAssigns; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcRelAssignsToControl; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcRelAssignsTasks; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcRelAssignsToActor; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcRelAssignsToGroup; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcRelAssignsToProcess; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcRelAssignsToProduct; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcRelAssignsToProjectOrder; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcRelAssignsToResource; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcRelAssociates; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcRelAssociatesAppliedValue; // (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)
|
|
typedef NotImplemented IfcRelAssociatesProfileProperties; // (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 IfcRelConnectsStructuralElement; // (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)
|
|
struct IfcRelDefines;
|
|
struct IfcRelDefinesByProperties;
|
|
typedef NotImplemented IfcRelDefinesByType; // (not currently used by Assimp)
|
|
struct IfcRelFillsElement;
|
|
typedef NotImplemented IfcRelFlowControlElements; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcRelInteractionRequirements; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcRelNests; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcRelOccupiesSpaces; // (not currently used by Assimp)
|
|
struct IfcRelOverridesProperties;
|
|
typedef NotImplemented IfcRelProjectsElement; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcRelReferencedInSpatialStructure; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcRelSchedulesCostItems; // (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)
|
|
struct IfcRelVoidsElement;
|
|
typedef NotImplemented IfcRelaxation; // (not currently used by Assimp)
|
|
struct IfcRepresentation;
|
|
struct IfcRepresentationMap;
|
|
struct IfcRevolvedAreaSolid;
|
|
typedef NotImplemented IfcRibPlateProfileProperties; // (not currently used by Assimp)
|
|
struct IfcRightCircularCone;
|
|
struct IfcRightCircularCylinder;
|
|
struct IfcRoof;
|
|
struct IfcRoundedEdgeFeature;
|
|
struct IfcRoundedRectangleProfileDef;
|
|
struct IfcSIUnit;
|
|
struct IfcSanitaryTerminalType;
|
|
struct IfcScheduleTimeControl;
|
|
typedef NotImplemented IfcSectionProperties; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcSectionReinforcementProperties; // (not currently used by Assimp)
|
|
struct IfcSectionedSpine;
|
|
struct IfcSensorType;
|
|
struct IfcServiceLife;
|
|
typedef NotImplemented IfcServiceLifeFactor; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcShapeAspect; // (not currently used by Assimp)
|
|
struct IfcShapeModel;
|
|
struct IfcShapeRepresentation;
|
|
struct IfcShellBasedSurfaceModel;
|
|
struct IfcSite;
|
|
struct IfcSlab;
|
|
struct IfcSlabType;
|
|
typedef NotImplemented IfcSlippageConnectionCondition; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcSoundProperties; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcSoundValue; // (not currently used by Assimp)
|
|
struct IfcSpace;
|
|
struct IfcSpaceHeaterType;
|
|
struct IfcSpaceProgram;
|
|
typedef NotImplemented IfcSpaceThermalLoadProperties; // (not currently used by Assimp)
|
|
struct IfcSpatialStructureElementType;
|
|
struct IfcSpaceType;
|
|
struct IfcSphere;
|
|
struct IfcStackTerminalType;
|
|
struct IfcStair;
|
|
struct IfcStairFlight;
|
|
struct IfcStairFlightType;
|
|
struct IfcStructuralActivity;
|
|
struct IfcStructuralAction;
|
|
struct IfcStructuralAnalysisModel;
|
|
struct IfcStructuralItem;
|
|
struct IfcStructuralConnection;
|
|
struct IfcStructuralCurveConnection;
|
|
struct IfcStructuralMember;
|
|
struct IfcStructuralCurveMember;
|
|
struct IfcStructuralCurveMemberVarying;
|
|
struct IfcStructuralLinearAction;
|
|
struct IfcStructuralLinearActionVarying;
|
|
typedef NotImplemented IfcStructuralLoad; // (not currently used by Assimp)
|
|
struct IfcStructuralLoadGroup;
|
|
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 IfcStructuralPlanarAction;
|
|
struct IfcStructuralPlanarActionVarying;
|
|
struct IfcStructuralPointAction;
|
|
struct IfcStructuralPointConnection;
|
|
struct IfcStructuralReaction;
|
|
struct IfcStructuralPointReaction;
|
|
typedef NotImplemented IfcStructuralProfileProperties; // (not currently used by Assimp)
|
|
struct IfcStructuralResultGroup;
|
|
typedef NotImplemented IfcStructuralSteelProfileProperties; // (not currently used by Assimp)
|
|
struct IfcStructuralSurfaceConnection;
|
|
struct IfcStructuralSurfaceMember;
|
|
struct IfcStructuralSurfaceMemberVarying;
|
|
struct IfcStructuredDimensionCallout;
|
|
struct IfcStyleModel;
|
|
struct IfcStyledRepresentation;
|
|
struct IfcSubContractResource;
|
|
struct IfcSubedge;
|
|
struct IfcSurfaceCurveSweptAreaSolid;
|
|
struct IfcSweptSurface;
|
|
struct IfcSurfaceOfLinearExtrusion;
|
|
struct IfcSurfaceOfRevolution;
|
|
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 IfcSwitchingDeviceType;
|
|
typedef NotImplemented IfcSymbolStyle; // (not currently used by Assimp)
|
|
struct IfcSystemFurnitureElementType;
|
|
struct IfcTShapeProfileDef;
|
|
typedef NotImplemented IfcTable; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcTableRow; // (not currently used by Assimp)
|
|
struct IfcTankType;
|
|
typedef NotImplemented IfcTelecomAddress; // (not currently used by Assimp)
|
|
struct IfcTendon;
|
|
struct IfcTendonAnchor;
|
|
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 IfcTextStyleWithBoxCharacteristics; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcTextureCoordinate; // (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 IfcThermalMaterialProperties; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcTimeSeriesReferenceRelationship; // (not currently used by Assimp)
|
|
struct IfcTimeSeriesSchedule;
|
|
typedef NotImplemented IfcTimeSeriesValue; // (not currently used by Assimp)
|
|
struct IfcTopologyRepresentation;
|
|
struct IfcTransformerType;
|
|
struct IfcTransportElement;
|
|
struct IfcTransportElementType;
|
|
struct IfcTrapeziumProfileDef;
|
|
struct IfcTrimmedCurve;
|
|
struct IfcTubeBundleType;
|
|
struct IfcTwoDirectionRepeatFactor;
|
|
struct IfcUShapeProfileDef;
|
|
struct IfcUnitAssignment;
|
|
struct IfcUnitaryEquipmentType;
|
|
struct IfcValveType;
|
|
struct IfcVector;
|
|
struct IfcVertex;
|
|
typedef NotImplemented IfcVertexBasedTextureMap; // (not currently used by Assimp)
|
|
struct IfcVertexLoop;
|
|
struct IfcVertexPoint;
|
|
struct IfcVibrationIsolatorType;
|
|
struct IfcVirtualElement;
|
|
typedef NotImplemented IfcVirtualGridIntersection; // (not currently used by Assimp)
|
|
struct IfcWall;
|
|
struct IfcWallStandardCase;
|
|
struct IfcWallType;
|
|
struct IfcWasteTerminalType;
|
|
typedef NotImplemented IfcWaterProperties; // (not currently used by Assimp)
|
|
struct IfcWindow;
|
|
typedef NotImplemented IfcWindowLiningProperties; // (not currently used by Assimp)
|
|
typedef NotImplemented IfcWindowPanelProperties; // (not currently used by Assimp)
|
|
struct IfcWindowStyle;
|
|
struct IfcWorkControl;
|
|
struct IfcWorkPlan;
|
|
struct IfcWorkSchedule;
|
|
struct IfcZShapeProfileDef;
|
|
struct IfcZone;
|
|
|
|
|
|
|
|
// 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 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 IfcCompositeCurve
|
|
struct IfcCompositeCurve : IfcBoundedCurve, ObjectHelper<IfcCompositeCurve,2> { IfcCompositeCurve() : Object("IfcCompositeCurve") {}
|
|
ListOf< Lazy< IfcCompositeCurveSegment >, 1, 0 > Segments;
|
|
LOGICAL::Out SelfIntersect;
|
|
};
|
|
|
|
// C++ wrapper for Ifc2DCompositeCurve
|
|
struct Ifc2DCompositeCurve : IfcCompositeCurve, ObjectHelper<Ifc2DCompositeCurve,0> { Ifc2DCompositeCurve() : Object("Ifc2DCompositeCurve") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcRoot
|
|
struct IfcRoot : ObjectHelper<IfcRoot,4> { IfcRoot() : Object("IfcRoot") {}
|
|
IfcGloballyUniqueId::Out GlobalId;
|
|
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,0> { IfcControl() : Object("IfcControl") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcActionRequest
|
|
struct IfcActionRequest : IfcControl, ObjectHelper<IfcActionRequest,1> { IfcActionRequest() : Object("IfcActionRequest") {}
|
|
IfcIdentifier::Out RequestID;
|
|
};
|
|
|
|
// C++ wrapper for IfcActor
|
|
struct IfcActor : IfcObject, ObjectHelper<IfcActor,1> { IfcActor() : Object("IfcActor") {}
|
|
IfcActorSelect::Out TheActor;
|
|
};
|
|
|
|
// C++ wrapper for IfcTypeObject
|
|
struct IfcTypeObject : IfcObjectDefinition, ObjectHelper<IfcTypeObject,2> { IfcTypeObject() : Object("IfcTypeObject") {}
|
|
Maybe< IfcLabel::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 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 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 IfcAlarmType
|
|
struct IfcAlarmType : IfcDistributionControlElementType, ObjectHelper<IfcAlarmType,1> { IfcAlarmType() : Object("IfcAlarmType") {}
|
|
IfcAlarmTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcDraughtingCallout
|
|
struct IfcDraughtingCallout : IfcGeometricRepresentationItem, ObjectHelper<IfcDraughtingCallout,1> { IfcDraughtingCallout() : Object("IfcDraughtingCallout") {}
|
|
ListOf< IfcDraughtingCalloutElement, 1, 0 >::Out Contents;
|
|
};
|
|
|
|
// C++ wrapper for IfcDimensionCurveDirectedCallout
|
|
struct IfcDimensionCurveDirectedCallout : IfcDraughtingCallout, ObjectHelper<IfcDimensionCurveDirectedCallout,0> { IfcDimensionCurveDirectedCallout() : Object("IfcDimensionCurveDirectedCallout") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcAngularDimension
|
|
struct IfcAngularDimension : IfcDimensionCurveDirectedCallout, ObjectHelper<IfcAngularDimension,0> { IfcAngularDimension() : Object("IfcAngularDimension") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcProduct
|
|
struct IfcProduct : IfcObject, ObjectHelper<IfcProduct,2> { IfcProduct() : Object("IfcProduct") {}
|
|
Maybe< Lazy< IfcObjectPlacement > > ObjectPlacement;
|
|
Maybe< Lazy< IfcProductRepresentation > > Representation;
|
|
};
|
|
|
|
// C++ wrapper for IfcAnnotation
|
|
struct IfcAnnotation : IfcProduct, ObjectHelper<IfcAnnotation,0> { IfcAnnotation() : Object("IfcAnnotation") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcStyledItem
|
|
struct IfcStyledItem : IfcRepresentationItem, ObjectHelper<IfcStyledItem,3> { IfcStyledItem() : Object("IfcStyledItem") {}
|
|
Maybe< Lazy< IfcRepresentationItem > > Item;
|
|
ListOf< Lazy< IfcPresentationStyleAssignment >, 1, 0 > Styles;
|
|
Maybe< IfcLabel::Out > Name;
|
|
};
|
|
|
|
// C++ wrapper for IfcAnnotationOccurrence
|
|
struct IfcAnnotationOccurrence : IfcStyledItem, ObjectHelper<IfcAnnotationOccurrence,0> { IfcAnnotationOccurrence() : Object("IfcAnnotationOccurrence") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcAnnotationCurveOccurrence
|
|
struct IfcAnnotationCurveOccurrence : IfcAnnotationOccurrence, ObjectHelper<IfcAnnotationCurveOccurrence,0> { IfcAnnotationCurveOccurrence() : Object("IfcAnnotationCurveOccurrence") {}
|
|
|
|
};
|
|
|
|
// 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 IfcAnnotationFillAreaOccurrence
|
|
struct IfcAnnotationFillAreaOccurrence : IfcAnnotationOccurrence, ObjectHelper<IfcAnnotationFillAreaOccurrence,2> { IfcAnnotationFillAreaOccurrence() : Object("IfcAnnotationFillAreaOccurrence") {}
|
|
Maybe< Lazy< IfcPoint > > FillStyleTarget;
|
|
Maybe< IfcGlobalOrLocalEnum::Out > GlobalOrLocal;
|
|
};
|
|
|
|
// C++ wrapper for IfcAnnotationSurface
|
|
struct IfcAnnotationSurface : IfcGeometricRepresentationItem, ObjectHelper<IfcAnnotationSurface,2> { IfcAnnotationSurface() : Object("IfcAnnotationSurface") {}
|
|
Lazy< IfcGeometricRepresentationItem > Item;
|
|
Maybe< Lazy< NotImplemented > > TextureCoordinates;
|
|
};
|
|
|
|
// C++ wrapper for IfcAnnotationSurfaceOccurrence
|
|
struct IfcAnnotationSurfaceOccurrence : IfcAnnotationOccurrence, ObjectHelper<IfcAnnotationSurfaceOccurrence,0> { IfcAnnotationSurfaceOccurrence() : Object("IfcAnnotationSurfaceOccurrence") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcAnnotationSymbolOccurrence
|
|
struct IfcAnnotationSymbolOccurrence : IfcAnnotationOccurrence, ObjectHelper<IfcAnnotationSymbolOccurrence,0> { IfcAnnotationSymbolOccurrence() : Object("IfcAnnotationSymbolOccurrence") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcAnnotationTextOccurrence
|
|
struct IfcAnnotationTextOccurrence : IfcAnnotationOccurrence, ObjectHelper<IfcAnnotationTextOccurrence,0> { IfcAnnotationTextOccurrence() : Object("IfcAnnotationTextOccurrence") {}
|
|
|
|
};
|
|
|
|
// 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") {}
|
|
IfcIdentifier::Out AssetID;
|
|
Lazy< NotImplemented > OriginalValue;
|
|
Lazy< NotImplemented > CurrentValue;
|
|
Lazy< NotImplemented > TotalReplacementCost;
|
|
IfcActorSelect::Out Owner;
|
|
IfcActorSelect::Out User;
|
|
Lazy< NotImplemented > ResponsiblePerson;
|
|
Lazy< NotImplemented > IncorporationDate;
|
|
Lazy< NotImplemented > DepreciatedValue;
|
|
};
|
|
|
|
// C++ wrapper for IfcParameterizedProfileDef
|
|
struct IfcParameterizedProfileDef : IfcProfileDef, ObjectHelper<IfcParameterizedProfileDef,1> { IfcParameterizedProfileDef() : Object("IfcParameterizedProfileDef") {}
|
|
Lazy< IfcAxis2Placement2D > Position;
|
|
};
|
|
|
|
// C++ wrapper for IfcIShapeProfileDef
|
|
struct IfcIShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcIShapeProfileDef,5> { IfcIShapeProfileDef() : Object("IfcIShapeProfileDef") {}
|
|
IfcPositiveLengthMeasure::Out OverallWidth;
|
|
IfcPositiveLengthMeasure::Out OverallDepth;
|
|
IfcPositiveLengthMeasure::Out WebThickness;
|
|
IfcPositiveLengthMeasure::Out FlangeThickness;
|
|
Maybe< IfcPositiveLengthMeasure::Out > FilletRadius;
|
|
};
|
|
|
|
// C++ wrapper for IfcAsymmetricIShapeProfileDef
|
|
struct IfcAsymmetricIShapeProfileDef : IfcIShapeProfileDef, ObjectHelper<IfcAsymmetricIShapeProfileDef,4> { IfcAsymmetricIShapeProfileDef() : Object("IfcAsymmetricIShapeProfileDef") {}
|
|
IfcPositiveLengthMeasure::Out TopFlangeWidth;
|
|
Maybe< IfcPositiveLengthMeasure::Out > TopFlangeThickness;
|
|
Maybe< IfcPositiveLengthMeasure::Out > TopFlangeFilletRadius;
|
|
Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInY;
|
|
};
|
|
|
|
// 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 IfcBSplineCurve
|
|
struct IfcBSplineCurve : IfcBoundedCurve, ObjectHelper<IfcBSplineCurve,5> { IfcBSplineCurve() : Object("IfcBSplineCurve") {}
|
|
INTEGER::Out Degree;
|
|
ListOf< Lazy< IfcCartesianPoint >, 2, 0 > ControlPointsList;
|
|
IfcBSplineCurveForm::Out CurveForm;
|
|
LOGICAL::Out ClosedCurve;
|
|
LOGICAL::Out SelfIntersect;
|
|
};
|
|
|
|
// C++ wrapper for IfcElement
|
|
struct IfcElement : IfcProduct, ObjectHelper<IfcElement,1> { IfcElement() : Object("IfcElement") {}
|
|
Maybe< IfcIdentifier::Out > Tag;
|
|
};
|
|
|
|
// C++ wrapper for IfcBuildingElement
|
|
struct IfcBuildingElement : IfcElement, ObjectHelper<IfcBuildingElement,0> { IfcBuildingElement() : Object("IfcBuildingElement") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcBeam
|
|
struct IfcBeam : IfcBuildingElement, ObjectHelper<IfcBeam,0> { IfcBeam() : Object("IfcBeam") {}
|
|
|
|
};
|
|
|
|
// 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 IfcBezierCurve
|
|
struct IfcBezierCurve : IfcBSplineCurve, ObjectHelper<IfcBezierCurve,0> { IfcBezierCurve() : Object("IfcBezierCurve") {}
|
|
|
|
};
|
|
|
|
// 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 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 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 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;
|
|
BOOLEAN::Out AgreementFlag;
|
|
};
|
|
|
|
// C++ wrapper for IfcBoxedHalfSpace
|
|
struct IfcBoxedHalfSpace : IfcHalfSpaceSolid, ObjectHelper<IfcBoxedHalfSpace,1> { IfcBoxedHalfSpace() : Object("IfcBoxedHalfSpace") {}
|
|
Lazy< IfcBoundingBox > Enclosure;
|
|
};
|
|
|
|
// C++ wrapper for IfcSpatialStructureElement
|
|
struct IfcSpatialStructureElement : IfcProduct, ObjectHelper<IfcSpatialStructureElement,2> { IfcSpatialStructureElement() : Object("IfcSpatialStructureElement") {}
|
|
Maybe< IfcLabel::Out > LongName;
|
|
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 IfcBuildingElementComponent
|
|
struct IfcBuildingElementComponent : IfcBuildingElement, ObjectHelper<IfcBuildingElementComponent,0> { IfcBuildingElementComponent() : Object("IfcBuildingElementComponent") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcBuildingElementPart
|
|
struct IfcBuildingElementPart : IfcBuildingElementComponent, ObjectHelper<IfcBuildingElementPart,0> { IfcBuildingElementPart() : Object("IfcBuildingElementPart") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcBuildingElementProxy
|
|
struct IfcBuildingElementProxy : IfcBuildingElement, ObjectHelper<IfcBuildingElementProxy,1> { IfcBuildingElementProxy() : Object("IfcBuildingElementProxy") {}
|
|
Maybe< IfcElementCompositionEnum::Out > CompositionType;
|
|
};
|
|
|
|
// 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 IfcCShapeProfileDef
|
|
struct IfcCShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcCShapeProfileDef,6> { IfcCShapeProfileDef() : Object("IfcCShapeProfileDef") {}
|
|
IfcPositiveLengthMeasure::Out Depth;
|
|
IfcPositiveLengthMeasure::Out Width;
|
|
IfcPositiveLengthMeasure::Out WallThickness;
|
|
IfcPositiveLengthMeasure::Out Girth;
|
|
Maybe< IfcPositiveLengthMeasure::Out > InternalFilletRadius;
|
|
Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInX;
|
|
};
|
|
|
|
// 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 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 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 IfcCartesianTransformationOperator
|
|
struct IfcCartesianTransformationOperator : IfcGeometricRepresentationItem, ObjectHelper<IfcCartesianTransformationOperator,4> { IfcCartesianTransformationOperator() : Object("IfcCartesianTransformationOperator") {}
|
|
Maybe< Lazy< IfcDirection > > Axis1;
|
|
Maybe< Lazy< IfcDirection > > Axis2;
|
|
Lazy< IfcCartesianPoint > LocalOrigin;
|
|
Maybe< REAL::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< REAL::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< REAL::Out > Scale2;
|
|
Maybe< REAL::Out > Scale3;
|
|
};
|
|
|
|
// C++ wrapper for IfcCenterLineProfileDef
|
|
struct IfcCenterLineProfileDef : IfcArbitraryOpenProfileDef, ObjectHelper<IfcCenterLineProfileDef,1> { IfcCenterLineProfileDef() : Object("IfcCenterLineProfileDef") {}
|
|
IfcPositiveLengthMeasure::Out Thickness;
|
|
};
|
|
|
|
// C++ wrapper for IfcFeatureElement
|
|
struct IfcFeatureElement : IfcElement, ObjectHelper<IfcFeatureElement,0> { IfcFeatureElement() : Object("IfcFeatureElement") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcFeatureElementSubtraction
|
|
struct IfcFeatureElementSubtraction : IfcFeatureElement, ObjectHelper<IfcFeatureElementSubtraction,0> { IfcFeatureElementSubtraction() : Object("IfcFeatureElementSubtraction") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcEdgeFeature
|
|
struct IfcEdgeFeature : IfcFeatureElementSubtraction, ObjectHelper<IfcEdgeFeature,1> { IfcEdgeFeature() : Object("IfcEdgeFeature") {}
|
|
Maybe< IfcPositiveLengthMeasure::Out > FeatureLength;
|
|
};
|
|
|
|
// C++ wrapper for IfcChamferEdgeFeature
|
|
struct IfcChamferEdgeFeature : IfcEdgeFeature, ObjectHelper<IfcChamferEdgeFeature,2> { IfcChamferEdgeFeature() : Object("IfcChamferEdgeFeature") {}
|
|
Maybe< IfcPositiveLengthMeasure::Out > Width;
|
|
Maybe< IfcPositiveLengthMeasure::Out > Height;
|
|
};
|
|
|
|
// C++ wrapper for IfcChillerType
|
|
struct IfcChillerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcChillerType,1> { IfcChillerType() : Object("IfcChillerType") {}
|
|
IfcChillerTypeEnum::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 IfcTopologicalRepresentationItem
|
|
struct IfcTopologicalRepresentationItem : IfcRepresentationItem, ObjectHelper<IfcTopologicalRepresentationItem,0> { IfcTopologicalRepresentationItem() : Object("IfcTopologicalRepresentationItem") {}
|
|
|
|
};
|
|
|
|
// 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 IfcCoilType
|
|
struct IfcCoilType : IfcEnergyConversionDeviceType, ObjectHelper<IfcCoilType,1> { IfcCoilType() : Object("IfcCoilType") {}
|
|
IfcCoilTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcColourSpecification
|
|
struct IfcColourSpecification : 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,0> { IfcColumn() : Object("IfcColumn") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcColumnType
|
|
struct IfcColumnType : IfcBuildingElementType, ObjectHelper<IfcColumnType,1> { IfcColumnType() : Object("IfcColumnType") {}
|
|
IfcColumnTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcProperty
|
|
struct IfcProperty : 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 IfcCompositeCurveSegment
|
|
struct IfcCompositeCurveSegment : IfcGeometricRepresentationItem, ObjectHelper<IfcCompositeCurveSegment,3> { IfcCompositeCurveSegment() : Object("IfcCompositeCurveSegment") {}
|
|
IfcTransitionCode::Out Transition;
|
|
BOOLEAN::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 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 IfcCondenserType
|
|
struct IfcCondenserType : IfcEnergyConversionDeviceType, ObjectHelper<IfcCondenserType,1> { IfcCondenserType() : Object("IfcCondenserType") {}
|
|
IfcCondenserTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcCondition
|
|
struct IfcCondition : IfcGroup, ObjectHelper<IfcCondition,0> { IfcCondition() : Object("IfcCondition") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcConditionCriterion
|
|
struct IfcConditionCriterion : IfcControl, ObjectHelper<IfcConditionCriterion,2> { IfcConditionCriterion() : Object("IfcConditionCriterion") {}
|
|
IfcConditionCriterionSelect::Out Criterion;
|
|
IfcDateTimeSelect::Out CriterionDateTime;
|
|
};
|
|
|
|
// C++ wrapper for IfcResource
|
|
struct IfcResource : IfcObject, ObjectHelper<IfcResource,0> { IfcResource() : Object("IfcResource") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcConstructionResource
|
|
struct IfcConstructionResource : IfcResource, ObjectHelper<IfcConstructionResource,4> { IfcConstructionResource() : Object("IfcConstructionResource") {}
|
|
Maybe< IfcIdentifier::Out > ResourceIdentifier;
|
|
Maybe< IfcLabel::Out > ResourceGroup;
|
|
Maybe< IfcResourceConsumptionEnum::Out > ResourceConsumption;
|
|
Maybe< Lazy< IfcMeasureWithUnit > > BaseQuantity;
|
|
};
|
|
|
|
// C++ wrapper for IfcConstructionEquipmentResource
|
|
struct IfcConstructionEquipmentResource : IfcConstructionResource, ObjectHelper<IfcConstructionEquipmentResource,0> { IfcConstructionEquipmentResource() : Object("IfcConstructionEquipmentResource") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcConstructionMaterialResource
|
|
struct IfcConstructionMaterialResource : IfcConstructionResource, ObjectHelper<IfcConstructionMaterialResource,2> { IfcConstructionMaterialResource() : Object("IfcConstructionMaterialResource") {}
|
|
Maybe< ListOf< IfcActorSelect, 1, 0 >::Out > Suppliers;
|
|
Maybe< IfcRatioMeasure::Out > UsageRatio;
|
|
};
|
|
|
|
// C++ wrapper for IfcConstructionProductResource
|
|
struct IfcConstructionProductResource : IfcConstructionResource, ObjectHelper<IfcConstructionProductResource,0> { IfcConstructionProductResource() : Object("IfcConstructionProductResource") {}
|
|
|
|
};
|
|
|
|
// 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 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 IfcCooledBeamType
|
|
struct IfcCooledBeamType : IfcEnergyConversionDeviceType, ObjectHelper<IfcCooledBeamType,1> { IfcCooledBeamType() : Object("IfcCooledBeamType") {}
|
|
IfcCooledBeamTypeEnum::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,0> { IfcCostItem() : Object("IfcCostItem") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcCostSchedule
|
|
struct IfcCostSchedule : IfcControl, ObjectHelper<IfcCostSchedule,8> { IfcCostSchedule() : Object("IfcCostSchedule") {}
|
|
Maybe< IfcActorSelect::Out > SubmittedBy;
|
|
Maybe< IfcActorSelect::Out > PreparedBy;
|
|
Maybe< IfcDateTimeSelect::Out > SubmittedOn;
|
|
Maybe< IfcLabel::Out > Status;
|
|
Maybe< ListOf< IfcActorSelect, 1, 0 >::Out > TargetUsers;
|
|
Maybe< IfcDateTimeSelect::Out > UpdateDate;
|
|
IfcIdentifier::Out ID;
|
|
IfcCostScheduleTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// 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 IfcCraneRailAShapeProfileDef
|
|
struct IfcCraneRailAShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcCraneRailAShapeProfileDef,12> { IfcCraneRailAShapeProfileDef() : Object("IfcCraneRailAShapeProfileDef") {}
|
|
IfcPositiveLengthMeasure::Out OverallHeight;
|
|
IfcPositiveLengthMeasure::Out BaseWidth2;
|
|
Maybe< IfcPositiveLengthMeasure::Out > Radius;
|
|
IfcPositiveLengthMeasure::Out HeadWidth;
|
|
IfcPositiveLengthMeasure::Out HeadDepth2;
|
|
IfcPositiveLengthMeasure::Out HeadDepth3;
|
|
IfcPositiveLengthMeasure::Out WebThickness;
|
|
IfcPositiveLengthMeasure::Out BaseWidth4;
|
|
IfcPositiveLengthMeasure::Out BaseDepth1;
|
|
IfcPositiveLengthMeasure::Out BaseDepth2;
|
|
IfcPositiveLengthMeasure::Out BaseDepth3;
|
|
Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInY;
|
|
};
|
|
|
|
// C++ wrapper for IfcCraneRailFShapeProfileDef
|
|
struct IfcCraneRailFShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcCraneRailFShapeProfileDef,9> { IfcCraneRailFShapeProfileDef() : Object("IfcCraneRailFShapeProfileDef") {}
|
|
IfcPositiveLengthMeasure::Out OverallHeight;
|
|
IfcPositiveLengthMeasure::Out HeadWidth;
|
|
Maybe< IfcPositiveLengthMeasure::Out > Radius;
|
|
IfcPositiveLengthMeasure::Out HeadDepth2;
|
|
IfcPositiveLengthMeasure::Out HeadDepth3;
|
|
IfcPositiveLengthMeasure::Out WebThickness;
|
|
IfcPositiveLengthMeasure::Out BaseDepth1;
|
|
IfcPositiveLengthMeasure::Out BaseDepth2;
|
|
Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInY;
|
|
};
|
|
|
|
// C++ wrapper for IfcCrewResource
|
|
struct IfcCrewResource : IfcConstructionResource, ObjectHelper<IfcCrewResource,0> { IfcCrewResource() : Object("IfcCrewResource") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcSolidModel
|
|
struct IfcSolidModel : IfcGeometricRepresentationItem, ObjectHelper<IfcSolidModel,0> { IfcSolidModel() : Object("IfcSolidModel") {}
|
|
|
|
};
|
|
|
|
// 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,0> { IfcCurtainWall() : Object("IfcCurtainWall") {}
|
|
|
|
};
|
|
|
|
// 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 IfcPresentationStyle
|
|
struct IfcPresentationStyle : ObjectHelper<IfcPresentationStyle,1> { IfcPresentationStyle() : Object("IfcPresentationStyle") {}
|
|
Maybe< IfcLabel::Out > Name;
|
|
};
|
|
|
|
// C++ wrapper for IfcDamperType
|
|
struct IfcDamperType : IfcFlowControllerType, ObjectHelper<IfcDamperType,1> { IfcDamperType() : Object("IfcDamperType") {}
|
|
IfcDamperTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcDefinedSymbol
|
|
struct IfcDefinedSymbol : IfcGeometricRepresentationItem, ObjectHelper<IfcDefinedSymbol,2> { IfcDefinedSymbol() : Object("IfcDefinedSymbol") {}
|
|
IfcDefinedSymbolSelect::Out Definition;
|
|
Lazy< IfcCartesianTransformationOperator2D > Target;
|
|
};
|
|
|
|
// 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 IfcDiameterDimension
|
|
struct IfcDiameterDimension : IfcDimensionCurveDirectedCallout, ObjectHelper<IfcDiameterDimension,0> { IfcDiameterDimension() : Object("IfcDiameterDimension") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcDimensionCurve
|
|
struct IfcDimensionCurve : IfcAnnotationCurveOccurrence, ObjectHelper<IfcDimensionCurve,0> { IfcDimensionCurve() : Object("IfcDimensionCurve") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcTerminatorSymbol
|
|
struct IfcTerminatorSymbol : IfcAnnotationSymbolOccurrence, ObjectHelper<IfcTerminatorSymbol,1> { IfcTerminatorSymbol() : Object("IfcTerminatorSymbol") {}
|
|
Lazy< IfcAnnotationCurveOccurrence > AnnotatedCurve;
|
|
};
|
|
|
|
// C++ wrapper for IfcDimensionCurveTerminator
|
|
struct IfcDimensionCurveTerminator : IfcTerminatorSymbol, ObjectHelper<IfcDimensionCurveTerminator,1> { IfcDimensionCurveTerminator() : Object("IfcDimensionCurveTerminator") {}
|
|
IfcDimensionExtentUsage::Out Role;
|
|
};
|
|
|
|
// C++ wrapper for IfcDirection
|
|
struct IfcDirection : IfcGeometricRepresentationItem, ObjectHelper<IfcDirection,1> { IfcDirection() : Object("IfcDirection") {}
|
|
ListOf< REAL, 2, 3 >::Out DirectionRatios;
|
|
};
|
|
|
|
// C++ wrapper for IfcElementComponent
|
|
struct IfcElementComponent : IfcElement, ObjectHelper<IfcElementComponent,0> { IfcElementComponent() : Object("IfcElementComponent") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcDiscreteAccessory
|
|
struct IfcDiscreteAccessory : IfcElementComponent, ObjectHelper<IfcDiscreteAccessory,0> { IfcDiscreteAccessory() : Object("IfcDiscreteAccessory") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcElementComponentType
|
|
struct IfcElementComponentType : IfcElementType, ObjectHelper<IfcElementComponentType,0> { IfcElementComponentType() : Object("IfcElementComponentType") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcDiscreteAccessoryType
|
|
struct IfcDiscreteAccessoryType : IfcElementComponentType, ObjectHelper<IfcDiscreteAccessoryType,0> { IfcDiscreteAccessoryType() : Object("IfcDiscreteAccessoryType") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcDistributionElement
|
|
struct IfcDistributionElement : IfcElement, ObjectHelper<IfcDistributionElement,0> { IfcDistributionElement() : Object("IfcDistributionElement") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcDistributionFlowElement
|
|
struct IfcDistributionFlowElement : IfcDistributionElement, ObjectHelper<IfcDistributionFlowElement,0> { IfcDistributionFlowElement() : Object("IfcDistributionFlowElement") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcDistributionChamberElement
|
|
struct IfcDistributionChamberElement : IfcDistributionFlowElement, ObjectHelper<IfcDistributionChamberElement,0> { IfcDistributionChamberElement() : Object("IfcDistributionChamberElement") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcDistributionChamberElementType
|
|
struct IfcDistributionChamberElementType : IfcDistributionFlowElementType, ObjectHelper<IfcDistributionChamberElementType,1> { IfcDistributionChamberElementType() : Object("IfcDistributionChamberElementType") {}
|
|
IfcDistributionChamberElementTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcDistributionControlElement
|
|
struct IfcDistributionControlElement : IfcDistributionElement, ObjectHelper<IfcDistributionControlElement,1> { IfcDistributionControlElement() : Object("IfcDistributionControlElement") {}
|
|
Maybe< IfcIdentifier::Out > ControlElementId;
|
|
};
|
|
|
|
// C++ wrapper for IfcPort
|
|
struct IfcPort : IfcProduct, ObjectHelper<IfcPort,0> { IfcPort() : Object("IfcPort") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcDistributionPort
|
|
struct IfcDistributionPort : IfcPort, ObjectHelper<IfcDistributionPort,1> { IfcDistributionPort() : Object("IfcDistributionPort") {}
|
|
Maybe< IfcFlowDirectionEnum::Out > FlowDirection;
|
|
};
|
|
|
|
// C++ wrapper for IfcDoor
|
|
struct IfcDoor : IfcBuildingElement, ObjectHelper<IfcDoor,2> { IfcDoor() : Object("IfcDoor") {}
|
|
Maybe< IfcPositiveLengthMeasure::Out > OverallHeight;
|
|
Maybe< IfcPositiveLengthMeasure::Out > OverallWidth;
|
|
};
|
|
|
|
// C++ wrapper for IfcPropertyDefinition
|
|
struct IfcPropertyDefinition : IfcRoot, ObjectHelper<IfcPropertyDefinition,0> { IfcPropertyDefinition() : Object("IfcPropertyDefinition") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcPropertySetDefinition
|
|
struct IfcPropertySetDefinition : IfcPropertyDefinition, ObjectHelper<IfcPropertySetDefinition,0> { IfcPropertySetDefinition() : Object("IfcPropertySetDefinition") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcDoorStyle
|
|
struct IfcDoorStyle : IfcTypeProduct, ObjectHelper<IfcDoorStyle,4> { IfcDoorStyle() : Object("IfcDoorStyle") {}
|
|
IfcDoorStyleOperationEnum::Out OperationType;
|
|
IfcDoorStyleConstructionEnum::Out ConstructionType;
|
|
BOOLEAN::Out ParameterTakesPrecedence;
|
|
BOOLEAN::Out Sizeable;
|
|
};
|
|
|
|
// C++ wrapper for IfcDuctFittingType
|
|
struct IfcDuctFittingType : IfcFlowFittingType, ObjectHelper<IfcDuctFittingType,1> { IfcDuctFittingType() : Object("IfcDuctFittingType") {}
|
|
IfcDuctFittingTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcDuctSegmentType
|
|
struct IfcDuctSegmentType : IfcFlowSegmentType, ObjectHelper<IfcDuctSegmentType,1> { IfcDuctSegmentType() : Object("IfcDuctSegmentType") {}
|
|
IfcDuctSegmentTypeEnum::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;
|
|
BOOLEAN::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 IfcElectricApplianceType
|
|
struct IfcElectricApplianceType : IfcFlowTerminalType, ObjectHelper<IfcElectricApplianceType,1> { IfcElectricApplianceType() : Object("IfcElectricApplianceType") {}
|
|
IfcElectricApplianceTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcFlowController
|
|
struct IfcFlowController : IfcDistributionFlowElement, ObjectHelper<IfcFlowController,0> { IfcFlowController() : Object("IfcFlowController") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcElectricDistributionPoint
|
|
struct IfcElectricDistributionPoint : IfcFlowController, ObjectHelper<IfcElectricDistributionPoint,2> { IfcElectricDistributionPoint() : Object("IfcElectricDistributionPoint") {}
|
|
IfcElectricDistributionPointFunctionEnum::Out DistributionPointFunction;
|
|
Maybe< IfcLabel::Out > UserDefinedFunction;
|
|
};
|
|
|
|
// 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 IfcElectricGeneratorType
|
|
struct IfcElectricGeneratorType : IfcEnergyConversionDeviceType, ObjectHelper<IfcElectricGeneratorType,1> { IfcElectricGeneratorType() : Object("IfcElectricGeneratorType") {}
|
|
IfcElectricGeneratorTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcElectricHeaterType
|
|
struct IfcElectricHeaterType : IfcFlowTerminalType, ObjectHelper<IfcElectricHeaterType,1> { IfcElectricHeaterType() : Object("IfcElectricHeaterType") {}
|
|
IfcElectricHeaterTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcElectricMotorType
|
|
struct IfcElectricMotorType : IfcEnergyConversionDeviceType, ObjectHelper<IfcElectricMotorType,1> { IfcElectricMotorType() : Object("IfcElectricMotorType") {}
|
|
IfcElectricMotorTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcElectricTimeControlType
|
|
struct IfcElectricTimeControlType : IfcFlowControllerType, ObjectHelper<IfcElectricTimeControlType,1> { IfcElectricTimeControlType() : Object("IfcElectricTimeControlType") {}
|
|
IfcElectricTimeControlTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcSystem
|
|
struct IfcSystem : IfcGroup, ObjectHelper<IfcSystem,0> { IfcSystem() : Object("IfcSystem") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcElectricalCircuit
|
|
struct IfcElectricalCircuit : IfcSystem, ObjectHelper<IfcElectricalCircuit,0> { IfcElectricalCircuit() : Object("IfcElectricalCircuit") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcElectricalElement
|
|
struct IfcElectricalElement : IfcElement, ObjectHelper<IfcElectricalElement,0> { IfcElectricalElement() : Object("IfcElectricalElement") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcElementAssembly
|
|
struct IfcElementAssembly : IfcElement, ObjectHelper<IfcElementAssembly,2> { IfcElementAssembly() : Object("IfcElementAssembly") {}
|
|
Maybe< IfcAssemblyPlaceEnum::Out > AssemblyPlace;
|
|
IfcElementAssemblyTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcElementQuantity
|
|
struct IfcElementQuantity : IfcPropertySetDefinition, ObjectHelper<IfcElementQuantity,2> { IfcElementQuantity() : Object("IfcElementQuantity") {}
|
|
Maybe< IfcLabel::Out > MethodOfMeasurement;
|
|
ListOf< Lazy< NotImplemented >, 1, 0 > Quantities;
|
|
};
|
|
|
|
// C++ wrapper for IfcElementarySurface
|
|
struct IfcElementarySurface : IfcSurface, ObjectHelper<IfcElementarySurface,1> { IfcElementarySurface() : Object("IfcElementarySurface") {}
|
|
Lazy< IfcAxis2Placement3D > Position;
|
|
};
|
|
|
|
// 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 IfcEnergyConversionDevice
|
|
struct IfcEnergyConversionDevice : IfcDistributionFlowElement, ObjectHelper<IfcEnergyConversionDevice,0> { IfcEnergyConversionDevice() : Object("IfcEnergyConversionDevice") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcEquipmentElement
|
|
struct IfcEquipmentElement : IfcElement, ObjectHelper<IfcEquipmentElement,0> { IfcEquipmentElement() : Object("IfcEquipmentElement") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcEquipmentStandard
|
|
struct IfcEquipmentStandard : IfcControl, ObjectHelper<IfcEquipmentStandard,0> { IfcEquipmentStandard() : Object("IfcEquipmentStandard") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcEvaporativeCoolerType
|
|
struct IfcEvaporativeCoolerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcEvaporativeCoolerType,1> { IfcEvaporativeCoolerType() : Object("IfcEvaporativeCoolerType") {}
|
|
IfcEvaporativeCoolerTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcEvaporatorType
|
|
struct IfcEvaporatorType : IfcEnergyConversionDeviceType, ObjectHelper<IfcEvaporatorType,1> { IfcEvaporatorType() : Object("IfcEvaporatorType") {}
|
|
IfcEvaporatorTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcSweptAreaSolid
|
|
struct IfcSweptAreaSolid : IfcSolidModel, ObjectHelper<IfcSweptAreaSolid,2> { IfcSweptAreaSolid() : Object("IfcSweptAreaSolid") {}
|
|
Lazy< IfcProfileDef > SweptArea;
|
|
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 IfcFace
|
|
struct IfcFace : IfcTopologicalRepresentationItem, ObjectHelper<IfcFace,1> { IfcFace() : Object("IfcFace") {}
|
|
ListOf< Lazy< IfcFaceBound >, 1, 0 > Bounds;
|
|
};
|
|
|
|
// 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;
|
|
BOOLEAN::Out Orientation;
|
|
};
|
|
|
|
// C++ wrapper for IfcFaceOuterBound
|
|
struct IfcFaceOuterBound : IfcFaceBound, ObjectHelper<IfcFaceOuterBound,0> { IfcFaceOuterBound() : Object("IfcFaceOuterBound") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcFaceSurface
|
|
struct IfcFaceSurface : IfcFace, ObjectHelper<IfcFaceSurface,2> { IfcFaceSurface() : Object("IfcFaceSurface") {}
|
|
Lazy< IfcSurface > FaceSurface;
|
|
BOOLEAN::Out SameSense;
|
|
};
|
|
|
|
// C++ wrapper for IfcManifoldSolidBrep
|
|
struct IfcManifoldSolidBrep : IfcSolidModel, ObjectHelper<IfcManifoldSolidBrep,1> { IfcManifoldSolidBrep() : Object("IfcManifoldSolidBrep") {}
|
|
Lazy< IfcClosedShell > Outer;
|
|
};
|
|
|
|
// C++ wrapper for IfcFacetedBrep
|
|
struct IfcFacetedBrep : IfcManifoldSolidBrep, ObjectHelper<IfcFacetedBrep,0> { IfcFacetedBrep() : Object("IfcFacetedBrep") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcFacetedBrepWithVoids
|
|
struct IfcFacetedBrepWithVoids : IfcManifoldSolidBrep, ObjectHelper<IfcFacetedBrepWithVoids,1> { IfcFacetedBrepWithVoids() : Object("IfcFacetedBrepWithVoids") {}
|
|
ListOf< Lazy< IfcClosedShell >, 1, 0 > Voids;
|
|
};
|
|
|
|
// 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,0> { IfcFastener() : Object("IfcFastener") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcFastenerType
|
|
struct IfcFastenerType : IfcElementComponentType, ObjectHelper<IfcFastenerType,0> { IfcFastenerType() : Object("IfcFastenerType") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcFeatureElementAddition
|
|
struct IfcFeatureElementAddition : IfcFeatureElement, ObjectHelper<IfcFeatureElementAddition,0> { IfcFeatureElementAddition() : Object("IfcFeatureElementAddition") {}
|
|
|
|
};
|
|
|
|
// 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 IfcFillAreaStyleTileSymbolWithStyle
|
|
struct IfcFillAreaStyleTileSymbolWithStyle : IfcGeometricRepresentationItem, ObjectHelper<IfcFillAreaStyleTileSymbolWithStyle,1> { IfcFillAreaStyleTileSymbolWithStyle() : Object("IfcFillAreaStyleTileSymbolWithStyle") {}
|
|
Lazy< IfcAnnotationSymbolOccurrence > Symbol;
|
|
};
|
|
|
|
// C++ wrapper for IfcFillAreaStyleTiles
|
|
struct IfcFillAreaStyleTiles : IfcGeometricRepresentationItem, ObjectHelper<IfcFillAreaStyleTiles,3> { IfcFillAreaStyleTiles() : Object("IfcFillAreaStyleTiles") {}
|
|
Lazy< IfcOneDirectionRepeatFactor > TilingPattern;
|
|
ListOf< IfcFillAreaStyleTileShapeSelect, 1, 0 >::Out Tiles;
|
|
IfcPositiveRatioMeasure::Out TilingScale;
|
|
};
|
|
|
|
// C++ wrapper for IfcFilterType
|
|
struct IfcFilterType : IfcFlowTreatmentDeviceType, ObjectHelper<IfcFilterType,1> { IfcFilterType() : Object("IfcFilterType") {}
|
|
IfcFilterTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcFireSuppressionTerminalType
|
|
struct IfcFireSuppressionTerminalType : IfcFlowTerminalType, ObjectHelper<IfcFireSuppressionTerminalType,1> { IfcFireSuppressionTerminalType() : Object("IfcFireSuppressionTerminalType") {}
|
|
IfcFireSuppressionTerminalTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcFlowFitting
|
|
struct IfcFlowFitting : IfcDistributionFlowElement, ObjectHelper<IfcFlowFitting,0> { IfcFlowFitting() : Object("IfcFlowFitting") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcFlowInstrumentType
|
|
struct IfcFlowInstrumentType : IfcDistributionControlElementType, ObjectHelper<IfcFlowInstrumentType,1> { IfcFlowInstrumentType() : Object("IfcFlowInstrumentType") {}
|
|
IfcFlowInstrumentTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcFlowMeterType
|
|
struct IfcFlowMeterType : IfcFlowControllerType, ObjectHelper<IfcFlowMeterType,1> { IfcFlowMeterType() : Object("IfcFlowMeterType") {}
|
|
IfcFlowMeterTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcFlowMovingDevice
|
|
struct IfcFlowMovingDevice : IfcDistributionFlowElement, ObjectHelper<IfcFlowMovingDevice,0> { IfcFlowMovingDevice() : Object("IfcFlowMovingDevice") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcFlowSegment
|
|
struct IfcFlowSegment : IfcDistributionFlowElement, ObjectHelper<IfcFlowSegment,0> { IfcFlowSegment() : Object("IfcFlowSegment") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcFlowStorageDevice
|
|
struct IfcFlowStorageDevice : IfcDistributionFlowElement, ObjectHelper<IfcFlowStorageDevice,0> { IfcFlowStorageDevice() : Object("IfcFlowStorageDevice") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcFlowTerminal
|
|
struct IfcFlowTerminal : IfcDistributionFlowElement, ObjectHelper<IfcFlowTerminal,0> { IfcFlowTerminal() : Object("IfcFlowTerminal") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcFlowTreatmentDevice
|
|
struct IfcFlowTreatmentDevice : IfcDistributionFlowElement, ObjectHelper<IfcFlowTreatmentDevice,0> { IfcFlowTreatmentDevice() : Object("IfcFlowTreatmentDevice") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcFooting
|
|
struct IfcFooting : IfcBuildingElement, ObjectHelper<IfcFooting,1> { IfcFooting() : Object("IfcFooting") {}
|
|
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 IfcFurnitureStandard
|
|
struct IfcFurnitureStandard : IfcControl, ObjectHelper<IfcFurnitureStandard,0> { IfcFurnitureStandard() : Object("IfcFurnitureStandard") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcFurnitureType
|
|
struct IfcFurnitureType : IfcFurnishingElementType, ObjectHelper<IfcFurnitureType,1> { IfcFurnitureType() : Object("IfcFurnitureType") {}
|
|
IfcAssemblyPlaceEnum::Out AssemblyPlace;
|
|
};
|
|
|
|
// C++ wrapper for IfcGasTerminalType
|
|
struct IfcGasTerminalType : IfcFlowTerminalType, ObjectHelper<IfcGasTerminalType,1> { IfcGasTerminalType() : Object("IfcGasTerminalType") {}
|
|
IfcGasTerminalTypeEnum::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< REAL::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,3> { IfcGrid() : Object("IfcGrid") {}
|
|
ListOf< Lazy< NotImplemented >, 1, 0 > UAxes;
|
|
ListOf< Lazy< NotImplemented >, 1, 0 > VAxes;
|
|
Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > WAxes;
|
|
};
|
|
|
|
// 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< Lazy< NotImplemented > > PlacementRefDirection;
|
|
};
|
|
|
|
// C++ wrapper for IfcHeatExchangerType
|
|
struct IfcHeatExchangerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcHeatExchangerType,1> { IfcHeatExchangerType() : Object("IfcHeatExchangerType") {}
|
|
IfcHeatExchangerTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcHumidifierType
|
|
struct IfcHumidifierType : IfcEnergyConversionDeviceType, ObjectHelper<IfcHumidifierType,1> { IfcHumidifierType() : Object("IfcHumidifierType") {}
|
|
IfcHumidifierTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcInventory
|
|
struct IfcInventory : IfcGroup, ObjectHelper<IfcInventory,6> { IfcInventory() : Object("IfcInventory") {}
|
|
IfcInventoryTypeEnum::Out InventoryType;
|
|
IfcActorSelect::Out Jurisdiction;
|
|
ListOf< Lazy< NotImplemented >, 1, 0 > ResponsiblePersons;
|
|
Lazy< NotImplemented > LastUpdateDate;
|
|
Maybe< Lazy< NotImplemented > > CurrentValue;
|
|
Maybe< Lazy< NotImplemented > > OriginalValue;
|
|
};
|
|
|
|
// 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,8> { IfcLShapeProfileDef() : Object("IfcLShapeProfileDef") {}
|
|
IfcPositiveLengthMeasure::Out Depth;
|
|
Maybe< IfcPositiveLengthMeasure::Out > Width;
|
|
IfcPositiveLengthMeasure::Out Thickness;
|
|
Maybe< IfcPositiveLengthMeasure::Out > FilletRadius;
|
|
Maybe< IfcPositiveLengthMeasure::Out > EdgeRadius;
|
|
Maybe< IfcPlaneAngleMeasure::Out > LegSlope;
|
|
Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInX;
|
|
Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInY;
|
|
};
|
|
|
|
// C++ wrapper for IfcLaborResource
|
|
struct IfcLaborResource : IfcConstructionResource, ObjectHelper<IfcLaborResource,1> { IfcLaborResource() : Object("IfcLaborResource") {}
|
|
Maybe< IfcText::Out > SkillSet;
|
|
};
|
|
|
|
// C++ wrapper for IfcLampType
|
|
struct IfcLampType : IfcFlowTerminalType, ObjectHelper<IfcLampType,1> { IfcLampType() : Object("IfcLampType") {}
|
|
IfcLampTypeEnum::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 IfcLinearDimension
|
|
struct IfcLinearDimension : IfcDimensionCurveDirectedCallout, ObjectHelper<IfcLinearDimension,0> { IfcLinearDimension() : Object("IfcLinearDimension") {}
|
|
|
|
};
|
|
|
|
// 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 : IfcFastener, ObjectHelper<IfcMechanicalFastener,2> { IfcMechanicalFastener() : Object("IfcMechanicalFastener") {}
|
|
Maybe< IfcPositiveLengthMeasure::Out > NominalDiameter;
|
|
Maybe< IfcPositiveLengthMeasure::Out > NominalLength;
|
|
};
|
|
|
|
// C++ wrapper for IfcMechanicalFastenerType
|
|
struct IfcMechanicalFastenerType : IfcFastenerType, ObjectHelper<IfcMechanicalFastenerType,0> { IfcMechanicalFastenerType() : Object("IfcMechanicalFastenerType") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcMember
|
|
struct IfcMember : IfcBuildingElement, ObjectHelper<IfcMember,0> { IfcMember() : Object("IfcMember") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcMemberType
|
|
struct IfcMemberType : IfcBuildingElementType, ObjectHelper<IfcMemberType,1> { IfcMemberType() : Object("IfcMemberType") {}
|
|
IfcMemberTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcMotorConnectionType
|
|
struct IfcMotorConnectionType : IfcEnergyConversionDeviceType, ObjectHelper<IfcMotorConnectionType,1> { IfcMotorConnectionType() : Object("IfcMotorConnectionType") {}
|
|
IfcMotorConnectionTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcProcess
|
|
struct IfcProcess : IfcObject, ObjectHelper<IfcProcess,0> { IfcProcess() : Object("IfcProcess") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcTask
|
|
struct IfcTask : IfcProcess, ObjectHelper<IfcTask,5> { IfcTask() : Object("IfcTask") {}
|
|
IfcIdentifier::Out TaskId;
|
|
Maybe< IfcLabel::Out > Status;
|
|
Maybe< IfcLabel::Out > WorkMethod;
|
|
BOOLEAN::Out IsMilestone;
|
|
Maybe< INTEGER::Out > Priority;
|
|
};
|
|
|
|
// C++ wrapper for IfcMove
|
|
struct IfcMove : IfcTask, ObjectHelper<IfcMove,3> { IfcMove() : Object("IfcMove") {}
|
|
Lazy< IfcSpatialStructureElement > MoveFrom;
|
|
Lazy< IfcSpatialStructureElement > MoveTo;
|
|
Maybe< ListOf< IfcText, 1, 0 >::Out > PunchList;
|
|
};
|
|
|
|
// C++ wrapper for IfcOccupant
|
|
struct IfcOccupant : IfcActor, ObjectHelper<IfcOccupant,1> { IfcOccupant() : Object("IfcOccupant") {}
|
|
IfcOccupantTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcOffsetCurve2D
|
|
struct IfcOffsetCurve2D : IfcCurve, ObjectHelper<IfcOffsetCurve2D,3> { IfcOffsetCurve2D() : Object("IfcOffsetCurve2D") {}
|
|
Lazy< IfcCurve > BasisCurve;
|
|
IfcLengthMeasure::Out Distance;
|
|
LOGICAL::Out SelfIntersect;
|
|
};
|
|
|
|
// C++ wrapper for IfcOffsetCurve3D
|
|
struct IfcOffsetCurve3D : IfcCurve, ObjectHelper<IfcOffsetCurve3D,4> { IfcOffsetCurve3D() : Object("IfcOffsetCurve3D") {}
|
|
Lazy< IfcCurve > BasisCurve;
|
|
IfcLengthMeasure::Out Distance;
|
|
LOGICAL::Out SelfIntersect;
|
|
Lazy< IfcDirection > RefDirection;
|
|
};
|
|
|
|
// C++ wrapper for IfcOneDirectionRepeatFactor
|
|
struct IfcOneDirectionRepeatFactor : IfcGeometricRepresentationItem, ObjectHelper<IfcOneDirectionRepeatFactor,1> { IfcOneDirectionRepeatFactor() : Object("IfcOneDirectionRepeatFactor") {}
|
|
Lazy< IfcVector > RepeatFactor;
|
|
};
|
|
|
|
// C++ wrapper for IfcOpenShell
|
|
struct IfcOpenShell : IfcConnectedFaceSet, ObjectHelper<IfcOpenShell,0> { IfcOpenShell() : Object("IfcOpenShell") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcOpeningElement
|
|
struct IfcOpeningElement : IfcFeatureElementSubtraction, ObjectHelper<IfcOpeningElement,0> { IfcOpeningElement() : Object("IfcOpeningElement") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcOrderAction
|
|
struct IfcOrderAction : IfcTask, ObjectHelper<IfcOrderAction,1> { IfcOrderAction() : Object("IfcOrderAction") {}
|
|
IfcIdentifier::Out ActionID;
|
|
};
|
|
|
|
// C++ wrapper for IfcOrientedEdge
|
|
struct IfcOrientedEdge : IfcEdge, ObjectHelper<IfcOrientedEdge,2> { IfcOrientedEdge() : Object("IfcOrientedEdge") {}
|
|
Lazy< IfcEdge > EdgeElement;
|
|
BOOLEAN::Out Orientation;
|
|
};
|
|
|
|
// 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 IfcPerformanceHistory
|
|
struct IfcPerformanceHistory : IfcControl, ObjectHelper<IfcPerformanceHistory,1> { IfcPerformanceHistory() : Object("IfcPerformanceHistory") {}
|
|
IfcLabel::Out LifeCyclePhase;
|
|
};
|
|
|
|
// C++ wrapper for IfcPermit
|
|
struct IfcPermit : IfcControl, ObjectHelper<IfcPermit,1> { IfcPermit() : Object("IfcPermit") {}
|
|
IfcIdentifier::Out PermitID;
|
|
};
|
|
|
|
// C++ wrapper for IfcPile
|
|
struct IfcPile : IfcBuildingElement, ObjectHelper<IfcPile,2> { IfcPile() : Object("IfcPile") {}
|
|
IfcPileTypeEnum::Out PredefinedType;
|
|
Maybe< IfcPileConstructionEnum::Out > ConstructionType;
|
|
};
|
|
|
|
// C++ wrapper for IfcPipeFittingType
|
|
struct IfcPipeFittingType : IfcFlowFittingType, ObjectHelper<IfcPipeFittingType,1> { IfcPipeFittingType() : Object("IfcPipeFittingType") {}
|
|
IfcPipeFittingTypeEnum::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,0> { IfcPlate() : Object("IfcPlate") {}
|
|
|
|
};
|
|
|
|
// 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 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,3> { IfcProcedure() : Object("IfcProcedure") {}
|
|
IfcIdentifier::Out ProcedureID;
|
|
IfcProcedureTypeEnum::Out ProcedureType;
|
|
Maybe< IfcLabel::Out > UserDefinedProcedureType;
|
|
};
|
|
|
|
// C++ wrapper for IfcProductDefinitionShape
|
|
struct IfcProductDefinitionShape : IfcProductRepresentation, ObjectHelper<IfcProductDefinitionShape,0> { IfcProductDefinitionShape() : Object("IfcProductDefinitionShape") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcProject
|
|
struct IfcProject : IfcObject, ObjectHelper<IfcProject,4> { IfcProject() : Object("IfcProject") {}
|
|
Maybe< IfcLabel::Out > LongName;
|
|
Maybe< IfcLabel::Out > Phase;
|
|
ListOf< Lazy< IfcRepresentationContext >, 1, 0 > RepresentationContexts;
|
|
Lazy< IfcUnitAssignment > UnitsInContext;
|
|
};
|
|
|
|
// C++ wrapper for IfcProjectOrder
|
|
struct IfcProjectOrder : IfcControl, ObjectHelper<IfcProjectOrder,3> { IfcProjectOrder() : Object("IfcProjectOrder") {}
|
|
IfcIdentifier::Out ID;
|
|
IfcProjectOrderTypeEnum::Out PredefinedType;
|
|
Maybe< IfcLabel::Out > Status;
|
|
};
|
|
|
|
// C++ wrapper for IfcProjectOrderRecord
|
|
struct IfcProjectOrderRecord : IfcControl, ObjectHelper<IfcProjectOrderRecord,2> { IfcProjectOrderRecord() : Object("IfcProjectOrderRecord") {}
|
|
ListOf< Lazy< NotImplemented >, 1, 0 > Records;
|
|
IfcProjectOrderRecordTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcProjectionCurve
|
|
struct IfcProjectionCurve : IfcAnnotationCurveOccurrence, ObjectHelper<IfcProjectionCurve,0> { IfcProjectionCurve() : Object("IfcProjectionCurve") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcProjectionElement
|
|
struct IfcProjectionElement : IfcFeatureElementAddition, ObjectHelper<IfcProjectionElement,0> { IfcProjectionElement() : Object("IfcProjectionElement") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcSimpleProperty
|
|
struct IfcSimpleProperty : IfcProperty, ObjectHelper<IfcSimpleProperty,0> { IfcSimpleProperty() : Object("IfcSimpleProperty") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcPropertyBoundedValue
|
|
struct IfcPropertyBoundedValue : IfcSimpleProperty, ObjectHelper<IfcPropertyBoundedValue,3> { IfcPropertyBoundedValue() : Object("IfcPropertyBoundedValue") {}
|
|
Maybe< IfcValue::Out > UpperBoundValue;
|
|
Maybe< IfcValue::Out > LowerBoundValue;
|
|
Maybe< IfcUnit::Out > Unit;
|
|
};
|
|
|
|
// C++ wrapper for IfcPropertyEnumeratedValue
|
|
struct IfcPropertyEnumeratedValue : IfcSimpleProperty, ObjectHelper<IfcPropertyEnumeratedValue,2> { IfcPropertyEnumeratedValue() : Object("IfcPropertyEnumeratedValue") {}
|
|
ListOf< IfcValue, 1, 0 >::Out EnumerationValues;
|
|
Maybe< Lazy< NotImplemented > > EnumerationReference;
|
|
};
|
|
|
|
// C++ wrapper for IfcPropertyListValue
|
|
struct IfcPropertyListValue : IfcSimpleProperty, ObjectHelper<IfcPropertyListValue,2> { IfcPropertyListValue() : Object("IfcPropertyListValue") {}
|
|
ListOf< IfcValue, 1, 0 >::Out ListValues;
|
|
Maybe< IfcUnit::Out > Unit;
|
|
};
|
|
|
|
// C++ wrapper for IfcPropertyReferenceValue
|
|
struct IfcPropertyReferenceValue : IfcSimpleProperty, ObjectHelper<IfcPropertyReferenceValue,2> { IfcPropertyReferenceValue() : Object("IfcPropertyReferenceValue") {}
|
|
Maybe< IfcLabel::Out > UsageName;
|
|
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,5> { IfcPropertyTableValue() : Object("IfcPropertyTableValue") {}
|
|
ListOf< IfcValue, 1, 0 >::Out DefiningValues;
|
|
ListOf< IfcValue, 1, 0 >::Out DefinedValues;
|
|
Maybe< IfcText::Out > Expression;
|
|
Maybe< IfcUnit::Out > DefiningUnit;
|
|
Maybe< IfcUnit::Out > DefinedUnit;
|
|
};
|
|
|
|
// 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 IfcPumpType
|
|
struct IfcPumpType : IfcFlowMovingDeviceType, ObjectHelper<IfcPumpType,1> { IfcPumpType() : Object("IfcPumpType") {}
|
|
IfcPumpTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcRadiusDimension
|
|
struct IfcRadiusDimension : IfcDimensionCurveDirectedCallout, ObjectHelper<IfcRadiusDimension,0> { IfcRadiusDimension() : Object("IfcRadiusDimension") {}
|
|
|
|
};
|
|
|
|
// 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") {}
|
|
IfcRampTypeEnum::Out ShapeType;
|
|
};
|
|
|
|
// C++ wrapper for IfcRampFlight
|
|
struct IfcRampFlight : IfcBuildingElement, ObjectHelper<IfcRampFlight,0> { IfcRampFlight() : Object("IfcRampFlight") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcRampFlightType
|
|
struct IfcRampFlightType : IfcBuildingElementType, ObjectHelper<IfcRampFlightType,1> { IfcRampFlightType() : Object("IfcRampFlightType") {}
|
|
IfcRampFlightTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcRationalBezierCurve
|
|
struct IfcRationalBezierCurve : IfcBezierCurve, ObjectHelper<IfcRationalBezierCurve,1> { IfcRationalBezierCurve() : Object("IfcRationalBezierCurve") {}
|
|
ListOf< REAL, 2, 0 >::Out WeightsData;
|
|
};
|
|
|
|
// 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< IfcPositiveLengthMeasure::Out > InnerFilletRadius;
|
|
Maybe< IfcPositiveLengthMeasure::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;
|
|
BOOLEAN::Out Usense;
|
|
BOOLEAN::Out Vsense;
|
|
};
|
|
|
|
// C++ wrapper for IfcReinforcingElement
|
|
struct IfcReinforcingElement : IfcBuildingElementComponent, ObjectHelper<IfcReinforcingElement,1> { IfcReinforcingElement() : Object("IfcReinforcingElement") {}
|
|
Maybe< IfcLabel::Out > SteelGrade;
|
|
};
|
|
|
|
// C++ wrapper for IfcReinforcingBar
|
|
struct IfcReinforcingBar : IfcReinforcingElement, ObjectHelper<IfcReinforcingBar,5> { IfcReinforcingBar() : Object("IfcReinforcingBar") {}
|
|
IfcPositiveLengthMeasure::Out NominalDiameter;
|
|
IfcAreaMeasure::Out CrossSectionArea;
|
|
Maybe< IfcPositiveLengthMeasure::Out > BarLength;
|
|
IfcReinforcingBarRoleEnum::Out BarRole;
|
|
Maybe< IfcReinforcingBarSurfaceEnum::Out > BarSurface;
|
|
};
|
|
|
|
// C++ wrapper for IfcReinforcingMesh
|
|
struct IfcReinforcingMesh : IfcReinforcingElement, ObjectHelper<IfcReinforcingMesh,8> { IfcReinforcingMesh() : Object("IfcReinforcingMesh") {}
|
|
Maybe< IfcPositiveLengthMeasure::Out > MeshLength;
|
|
Maybe< IfcPositiveLengthMeasure::Out > MeshWidth;
|
|
IfcPositiveLengthMeasure::Out LongitudinalBarNominalDiameter;
|
|
IfcPositiveLengthMeasure::Out TransverseBarNominalDiameter;
|
|
IfcAreaMeasure::Out LongitudinalBarCrossSectionArea;
|
|
IfcAreaMeasure::Out TransverseBarCrossSectionArea;
|
|
IfcPositiveLengthMeasure::Out LongitudinalBarSpacing;
|
|
IfcPositiveLengthMeasure::Out TransverseBarSpacing;
|
|
};
|
|
|
|
// C++ wrapper for IfcRelationship
|
|
struct IfcRelationship : IfcRoot, ObjectHelper<IfcRelationship,0> { IfcRelationship() : Object("IfcRelationship") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcRelDecomposes
|
|
struct IfcRelDecomposes : IfcRelationship, ObjectHelper<IfcRelDecomposes,2> { IfcRelDecomposes() : Object("IfcRelDecomposes") {}
|
|
Lazy< IfcObjectDefinition > RelatingObject;
|
|
ListOf< Lazy< IfcObjectDefinition >, 1, 0 > RelatedObjects;
|
|
};
|
|
|
|
// C++ wrapper for IfcRelAggregates
|
|
struct IfcRelAggregates : IfcRelDecomposes, ObjectHelper<IfcRelAggregates,0> { IfcRelAggregates() : Object("IfcRelAggregates") {}
|
|
|
|
};
|
|
|
|
// 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< IfcSpatialStructureElement > RelatingStructure;
|
|
};
|
|
|
|
// C++ wrapper for IfcRelDefines
|
|
struct IfcRelDefines : IfcRelationship, ObjectHelper<IfcRelDefines,1> { IfcRelDefines() : Object("IfcRelDefines") {}
|
|
ListOf< Lazy< IfcObject >, 1, 0 > RelatedObjects;
|
|
};
|
|
|
|
// C++ wrapper for IfcRelDefinesByProperties
|
|
struct IfcRelDefinesByProperties : IfcRelDefines, ObjectHelper<IfcRelDefinesByProperties,1> { IfcRelDefinesByProperties() : Object("IfcRelDefinesByProperties") {}
|
|
Lazy< IfcPropertySetDefinition > RelatingPropertyDefinition;
|
|
};
|
|
|
|
// C++ wrapper for IfcRelFillsElement
|
|
struct IfcRelFillsElement : IfcRelConnects, ObjectHelper<IfcRelFillsElement,2> { IfcRelFillsElement() : Object("IfcRelFillsElement") {}
|
|
Lazy< IfcOpeningElement > RelatingOpeningElement;
|
|
Lazy< IfcElement > RelatedBuildingElement;
|
|
};
|
|
|
|
// C++ wrapper for IfcRelOverridesProperties
|
|
struct IfcRelOverridesProperties : IfcRelDefinesByProperties, ObjectHelper<IfcRelOverridesProperties,1> { IfcRelOverridesProperties() : Object("IfcRelOverridesProperties") {}
|
|
ListOf< Lazy< IfcProperty >, 1, 0 > OverridingProperties;
|
|
};
|
|
|
|
// C++ wrapper for IfcRelVoidsElement
|
|
struct IfcRelVoidsElement : IfcRelConnects, ObjectHelper<IfcRelVoidsElement,2> { IfcRelVoidsElement() : Object("IfcRelVoidsElement") {}
|
|
Lazy< IfcElement > RelatingBuildingElement;
|
|
Lazy< IfcFeatureElementSubtraction > RelatedOpeningElement;
|
|
};
|
|
|
|
// 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 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") {}
|
|
IfcRoofTypeEnum::Out ShapeType;
|
|
};
|
|
|
|
// C++ wrapper for IfcRoundedEdgeFeature
|
|
struct IfcRoundedEdgeFeature : IfcEdgeFeature, ObjectHelper<IfcRoundedEdgeFeature,1> { IfcRoundedEdgeFeature() : Object("IfcRoundedEdgeFeature") {}
|
|
Maybe< IfcPositiveLengthMeasure::Out > Radius;
|
|
};
|
|
|
|
// 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 IfcSanitaryTerminalType
|
|
struct IfcSanitaryTerminalType : IfcFlowTerminalType, ObjectHelper<IfcSanitaryTerminalType,1> { IfcSanitaryTerminalType() : Object("IfcSanitaryTerminalType") {}
|
|
IfcSanitaryTerminalTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcScheduleTimeControl
|
|
struct IfcScheduleTimeControl : IfcControl, ObjectHelper<IfcScheduleTimeControl,18> { IfcScheduleTimeControl() : Object("IfcScheduleTimeControl") {}
|
|
Maybe< IfcDateTimeSelect::Out > ActualStart;
|
|
Maybe< IfcDateTimeSelect::Out > EarlyStart;
|
|
Maybe< IfcDateTimeSelect::Out > LateStart;
|
|
Maybe< IfcDateTimeSelect::Out > ScheduleStart;
|
|
Maybe< IfcDateTimeSelect::Out > ActualFinish;
|
|
Maybe< IfcDateTimeSelect::Out > EarlyFinish;
|
|
Maybe< IfcDateTimeSelect::Out > LateFinish;
|
|
Maybe< IfcDateTimeSelect::Out > ScheduleFinish;
|
|
Maybe< IfcTimeMeasure::Out > ScheduleDuration;
|
|
Maybe< IfcTimeMeasure::Out > ActualDuration;
|
|
Maybe< IfcTimeMeasure::Out > RemainingTime;
|
|
Maybe< IfcTimeMeasure::Out > FreeFloat;
|
|
Maybe< IfcTimeMeasure::Out > TotalFloat;
|
|
Maybe< BOOLEAN::Out > IsCritical;
|
|
Maybe< IfcDateTimeSelect::Out > StatusTime;
|
|
Maybe< IfcTimeMeasure::Out > StartFloat;
|
|
Maybe< IfcTimeMeasure::Out > FinishFloat;
|
|
Maybe< IfcPositiveRatioMeasure::Out > Completion;
|
|
};
|
|
|
|
// 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 IfcSensorType
|
|
struct IfcSensorType : IfcDistributionControlElementType, ObjectHelper<IfcSensorType,1> { IfcSensorType() : Object("IfcSensorType") {}
|
|
IfcSensorTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcServiceLife
|
|
struct IfcServiceLife : IfcControl, ObjectHelper<IfcServiceLife,2> { IfcServiceLife() : Object("IfcServiceLife") {}
|
|
IfcServiceLifeTypeEnum::Out ServiceLifeType;
|
|
IfcTimeMeasure::Out ServiceLifeDuration;
|
|
};
|
|
|
|
// 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 IfcSlabType
|
|
struct IfcSlabType : IfcBuildingElementType, ObjectHelper<IfcSlabType,1> { IfcSlabType() : Object("IfcSlabType") {}
|
|
IfcSlabTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcSpace
|
|
struct IfcSpace : IfcSpatialStructureElement, ObjectHelper<IfcSpace,2> { IfcSpace() : Object("IfcSpace") {}
|
|
IfcInternalOrExternalEnum::Out InteriorOrExteriorSpace;
|
|
Maybe< IfcLengthMeasure::Out > ElevationWithFlooring;
|
|
};
|
|
|
|
// C++ wrapper for IfcSpaceHeaterType
|
|
struct IfcSpaceHeaterType : IfcEnergyConversionDeviceType, ObjectHelper<IfcSpaceHeaterType,1> { IfcSpaceHeaterType() : Object("IfcSpaceHeaterType") {}
|
|
IfcSpaceHeaterTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcSpaceProgram
|
|
struct IfcSpaceProgram : IfcControl, ObjectHelper<IfcSpaceProgram,5> { IfcSpaceProgram() : Object("IfcSpaceProgram") {}
|
|
IfcIdentifier::Out SpaceProgramIdentifier;
|
|
Maybe< IfcAreaMeasure::Out > MaxRequiredArea;
|
|
Maybe< IfcAreaMeasure::Out > MinRequiredArea;
|
|
Maybe< Lazy< IfcSpatialStructureElement > > RequestedLocation;
|
|
IfcAreaMeasure::Out StandardRequiredArea;
|
|
};
|
|
|
|
// C++ wrapper for IfcSpatialStructureElementType
|
|
struct IfcSpatialStructureElementType : IfcElementType, ObjectHelper<IfcSpatialStructureElementType,0> { IfcSpatialStructureElementType() : Object("IfcSpatialStructureElementType") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcSpaceType
|
|
struct IfcSpaceType : IfcSpatialStructureElementType, ObjectHelper<IfcSpaceType,1> { IfcSpaceType() : Object("IfcSpaceType") {}
|
|
IfcSpaceTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcSphere
|
|
struct IfcSphere : IfcCsgPrimitive3D, ObjectHelper<IfcSphere,1> { IfcSphere() : Object("IfcSphere") {}
|
|
IfcPositiveLengthMeasure::Out Radius;
|
|
};
|
|
|
|
// 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") {}
|
|
IfcStairTypeEnum::Out ShapeType;
|
|
};
|
|
|
|
// C++ wrapper for IfcStairFlight
|
|
struct IfcStairFlight : IfcBuildingElement, ObjectHelper<IfcStairFlight,4> { IfcStairFlight() : Object("IfcStairFlight") {}
|
|
Maybe< INTEGER::Out > NumberOfRiser;
|
|
Maybe< INTEGER::Out > NumberOfTreads;
|
|
Maybe< IfcPositiveLengthMeasure::Out > RiserHeight;
|
|
Maybe< IfcPositiveLengthMeasure::Out > TreadLength;
|
|
};
|
|
|
|
// C++ wrapper for IfcStairFlightType
|
|
struct IfcStairFlightType : IfcBuildingElementType, ObjectHelper<IfcStairFlightType,1> { IfcStairFlightType() : Object("IfcStairFlightType") {}
|
|
IfcStairFlightTypeEnum::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,2> { IfcStructuralAction() : Object("IfcStructuralAction") {}
|
|
BOOLEAN::Out DestabilizingLoad;
|
|
Maybe< Lazy< IfcStructuralReaction > > CausedBy;
|
|
};
|
|
|
|
// C++ wrapper for IfcStructuralAnalysisModel
|
|
struct IfcStructuralAnalysisModel : IfcSystem, ObjectHelper<IfcStructuralAnalysisModel,4> { IfcStructuralAnalysisModel() : Object("IfcStructuralAnalysisModel") {}
|
|
IfcAnalysisModelTypeEnum::Out PredefinedType;
|
|
Maybe< Lazy< IfcAxis2Placement3D > > OrientationOf2DPlane;
|
|
Maybe< ListOf< Lazy< IfcStructuralLoadGroup >, 1, 0 > > LoadedBy;
|
|
Maybe< ListOf< Lazy< IfcStructuralResultGroup >, 1, 0 > > HasResults;
|
|
};
|
|
|
|
// 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 IfcStructuralCurveConnection
|
|
struct IfcStructuralCurveConnection : IfcStructuralConnection, ObjectHelper<IfcStructuralCurveConnection,0> { IfcStructuralCurveConnection() : Object("IfcStructuralCurveConnection") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcStructuralMember
|
|
struct IfcStructuralMember : IfcStructuralItem, ObjectHelper<IfcStructuralMember,0> { IfcStructuralMember() : Object("IfcStructuralMember") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcStructuralCurveMember
|
|
struct IfcStructuralCurveMember : IfcStructuralMember, ObjectHelper<IfcStructuralCurveMember,1> { IfcStructuralCurveMember() : Object("IfcStructuralCurveMember") {}
|
|
IfcStructuralCurveTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcStructuralCurveMemberVarying
|
|
struct IfcStructuralCurveMemberVarying : IfcStructuralCurveMember, ObjectHelper<IfcStructuralCurveMemberVarying,0> { IfcStructuralCurveMemberVarying() : Object("IfcStructuralCurveMemberVarying") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcStructuralLinearAction
|
|
struct IfcStructuralLinearAction : IfcStructuralAction, ObjectHelper<IfcStructuralLinearAction,1> { IfcStructuralLinearAction() : Object("IfcStructuralLinearAction") {}
|
|
IfcProjectedOrTrueLengthEnum::Out ProjectedOrTrue;
|
|
};
|
|
|
|
// C++ wrapper for IfcStructuralLinearActionVarying
|
|
struct IfcStructuralLinearActionVarying : IfcStructuralLinearAction, ObjectHelper<IfcStructuralLinearActionVarying,2> { IfcStructuralLinearActionVarying() : Object("IfcStructuralLinearActionVarying") {}
|
|
Lazy< NotImplemented > VaryingAppliedLoadLocation;
|
|
ListOf< Lazy< NotImplemented >, 1, 0 > SubsequentAppliedLoads;
|
|
};
|
|
|
|
// C++ wrapper for IfcStructuralLoadGroup
|
|
struct IfcStructuralLoadGroup : IfcGroup, ObjectHelper<IfcStructuralLoadGroup,5> { IfcStructuralLoadGroup() : Object("IfcStructuralLoadGroup") {}
|
|
IfcLoadGroupTypeEnum::Out PredefinedType;
|
|
IfcActionTypeEnum::Out ActionType;
|
|
IfcActionSourceTypeEnum::Out ActionSource;
|
|
Maybe< IfcPositiveRatioMeasure::Out > Coefficient;
|
|
Maybe< IfcLabel::Out > Purpose;
|
|
};
|
|
|
|
// C++ wrapper for IfcStructuralPlanarAction
|
|
struct IfcStructuralPlanarAction : IfcStructuralAction, ObjectHelper<IfcStructuralPlanarAction,1> { IfcStructuralPlanarAction() : Object("IfcStructuralPlanarAction") {}
|
|
IfcProjectedOrTrueLengthEnum::Out ProjectedOrTrue;
|
|
};
|
|
|
|
// C++ wrapper for IfcStructuralPlanarActionVarying
|
|
struct IfcStructuralPlanarActionVarying : IfcStructuralPlanarAction, ObjectHelper<IfcStructuralPlanarActionVarying,2> { IfcStructuralPlanarActionVarying() : Object("IfcStructuralPlanarActionVarying") {}
|
|
Lazy< NotImplemented > VaryingAppliedLoadLocation;
|
|
ListOf< Lazy< NotImplemented >, 2, 0 > SubsequentAppliedLoads;
|
|
};
|
|
|
|
// C++ wrapper for IfcStructuralPointAction
|
|
struct IfcStructuralPointAction : IfcStructuralAction, ObjectHelper<IfcStructuralPointAction,0> { IfcStructuralPointAction() : Object("IfcStructuralPointAction") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcStructuralPointConnection
|
|
struct IfcStructuralPointConnection : IfcStructuralConnection, ObjectHelper<IfcStructuralPointConnection,0> { IfcStructuralPointConnection() : Object("IfcStructuralPointConnection") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcStructuralReaction
|
|
struct IfcStructuralReaction : IfcStructuralActivity, ObjectHelper<IfcStructuralReaction,0> { IfcStructuralReaction() : Object("IfcStructuralReaction") {}
|
|
|
|
};
|
|
|
|
// 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;
|
|
BOOLEAN::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") {}
|
|
IfcStructuralSurfaceTypeEnum::Out PredefinedType;
|
|
Maybe< IfcPositiveLengthMeasure::Out > Thickness;
|
|
};
|
|
|
|
// C++ wrapper for IfcStructuralSurfaceMemberVarying
|
|
struct IfcStructuralSurfaceMemberVarying : IfcStructuralSurfaceMember, ObjectHelper<IfcStructuralSurfaceMemberVarying,2> { IfcStructuralSurfaceMemberVarying() : Object("IfcStructuralSurfaceMemberVarying") {}
|
|
ListOf< IfcPositiveLengthMeasure, 2, 0 >::Out SubsequentThickness;
|
|
Lazy< NotImplemented > VaryingThicknessLocation;
|
|
};
|
|
|
|
// C++ wrapper for IfcStructuredDimensionCallout
|
|
struct IfcStructuredDimensionCallout : IfcDraughtingCallout, ObjectHelper<IfcStructuredDimensionCallout,0> { IfcStructuredDimensionCallout() : Object("IfcStructuredDimensionCallout") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcStyleModel
|
|
struct IfcStyleModel : IfcRepresentation, ObjectHelper<IfcStyleModel,0> { IfcStyleModel() : Object("IfcStyleModel") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcStyledRepresentation
|
|
struct IfcStyledRepresentation : IfcStyleModel, ObjectHelper<IfcStyledRepresentation,0> { IfcStyledRepresentation() : Object("IfcStyledRepresentation") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcSubContractResource
|
|
struct IfcSubContractResource : IfcConstructionResource, ObjectHelper<IfcSubContractResource,2> { IfcSubContractResource() : Object("IfcSubContractResource") {}
|
|
Maybe< IfcActorSelect::Out > SubContractor;
|
|
Maybe< IfcText::Out > JobDescription;
|
|
};
|
|
|
|
// 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;
|
|
IfcParameterValue::Out StartParam;
|
|
IfcParameterValue::Out EndParam;
|
|
Lazy< IfcSurface > ReferenceSurface;
|
|
};
|
|
|
|
// C++ wrapper for IfcSweptSurface
|
|
struct IfcSweptSurface : IfcSurface, ObjectHelper<IfcSweptSurface,2> { IfcSweptSurface() : Object("IfcSweptSurface") {}
|
|
Lazy< IfcProfileDef > SweptCurve;
|
|
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 : ObjectHelper<IfcSurfaceStyleShading,1> { IfcSurfaceStyleShading() : Object("IfcSurfaceStyleShading") {}
|
|
Lazy< IfcColourRgb > SurfaceColour;
|
|
};
|
|
|
|
// C++ wrapper for IfcSurfaceStyleRendering
|
|
struct IfcSurfaceStyleRendering : IfcSurfaceStyleShading, ObjectHelper<IfcSurfaceStyleRendering,8> { IfcSurfaceStyleRendering() : Object("IfcSurfaceStyleRendering") {}
|
|
Maybe< IfcNormalisedRatioMeasure::Out > Transparency;
|
|
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 : 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;
|
|
IfcParameterValue::Out StartParam;
|
|
IfcParameterValue::Out EndParam;
|
|
};
|
|
|
|
// C++ wrapper for IfcSwitchingDeviceType
|
|
struct IfcSwitchingDeviceType : IfcFlowControllerType, ObjectHelper<IfcSwitchingDeviceType,1> { IfcSwitchingDeviceType() : Object("IfcSwitchingDeviceType") {}
|
|
IfcSwitchingDeviceTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcSystemFurnitureElementType
|
|
struct IfcSystemFurnitureElementType : IfcFurnishingElementType, ObjectHelper<IfcSystemFurnitureElementType,0> { IfcSystemFurnitureElementType() : Object("IfcSystemFurnitureElementType") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcTShapeProfileDef
|
|
struct IfcTShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcTShapeProfileDef,10> { IfcTShapeProfileDef() : Object("IfcTShapeProfileDef") {}
|
|
IfcPositiveLengthMeasure::Out Depth;
|
|
IfcPositiveLengthMeasure::Out FlangeWidth;
|
|
IfcPositiveLengthMeasure::Out WebThickness;
|
|
IfcPositiveLengthMeasure::Out FlangeThickness;
|
|
Maybe< IfcPositiveLengthMeasure::Out > FilletRadius;
|
|
Maybe< IfcPositiveLengthMeasure::Out > FlangeEdgeRadius;
|
|
Maybe< IfcPositiveLengthMeasure::Out > WebEdgeRadius;
|
|
Maybe< IfcPlaneAngleMeasure::Out > WebSlope;
|
|
Maybe< IfcPlaneAngleMeasure::Out > FlangeSlope;
|
|
Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInY;
|
|
};
|
|
|
|
// C++ wrapper for IfcTankType
|
|
struct IfcTankType : IfcFlowStorageDeviceType, ObjectHelper<IfcTankType,1> { IfcTankType() : Object("IfcTankType") {}
|
|
IfcTankTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcTendon
|
|
struct IfcTendon : IfcReinforcingElement, ObjectHelper<IfcTendon,8> { IfcTendon() : Object("IfcTendon") {}
|
|
IfcTendonTypeEnum::Out PredefinedType;
|
|
IfcPositiveLengthMeasure::Out NominalDiameter;
|
|
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,0> { IfcTendonAnchor() : Object("IfcTendonAnchor") {}
|
|
|
|
};
|
|
|
|
// 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 IfcTimeSeriesSchedule
|
|
struct IfcTimeSeriesSchedule : IfcControl, ObjectHelper<IfcTimeSeriesSchedule,3> { IfcTimeSeriesSchedule() : Object("IfcTimeSeriesSchedule") {}
|
|
Maybe< ListOf< IfcDateTimeSelect, 1, 0 >::Out > ApplicableDates;
|
|
IfcTimeSeriesScheduleTypeEnum::Out TimeSeriesScheduleType;
|
|
Lazy< NotImplemented > TimeSeries;
|
|
};
|
|
|
|
// C++ wrapper for IfcTopologyRepresentation
|
|
struct IfcTopologyRepresentation : IfcShapeModel, ObjectHelper<IfcTopologyRepresentation,0> { IfcTopologyRepresentation() : Object("IfcTopologyRepresentation") {}
|
|
|
|
};
|
|
|
|
// 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,3> { IfcTransportElement() : Object("IfcTransportElement") {}
|
|
Maybe< IfcTransportElementTypeEnum::Out > OperationType;
|
|
Maybe< IfcMassMeasure::Out > CapacityByWeight;
|
|
Maybe< IfcCountMeasure::Out > CapacityByNumber;
|
|
};
|
|
|
|
// 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 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;
|
|
BOOLEAN::Out SenseAgreement;
|
|
IfcTrimmingPreference::Out MasterRepresentation;
|
|
};
|
|
|
|
// C++ wrapper for IfcTubeBundleType
|
|
struct IfcTubeBundleType : IfcEnergyConversionDeviceType, ObjectHelper<IfcTubeBundleType,1> { IfcTubeBundleType() : Object("IfcTubeBundleType") {}
|
|
IfcTubeBundleTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcTwoDirectionRepeatFactor
|
|
struct IfcTwoDirectionRepeatFactor : IfcOneDirectionRepeatFactor, ObjectHelper<IfcTwoDirectionRepeatFactor,1> { IfcTwoDirectionRepeatFactor() : Object("IfcTwoDirectionRepeatFactor") {}
|
|
Lazy< IfcVector > SecondRepeatFactor;
|
|
};
|
|
|
|
// C++ wrapper for IfcUShapeProfileDef
|
|
struct IfcUShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcUShapeProfileDef,8> { IfcUShapeProfileDef() : Object("IfcUShapeProfileDef") {}
|
|
IfcPositiveLengthMeasure::Out Depth;
|
|
IfcPositiveLengthMeasure::Out FlangeWidth;
|
|
IfcPositiveLengthMeasure::Out WebThickness;
|
|
IfcPositiveLengthMeasure::Out FlangeThickness;
|
|
Maybe< IfcPositiveLengthMeasure::Out > FilletRadius;
|
|
Maybe< IfcPositiveLengthMeasure::Out > EdgeRadius;
|
|
Maybe< IfcPlaneAngleMeasure::Out > FlangeSlope;
|
|
Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInX;
|
|
};
|
|
|
|
// C++ wrapper for IfcUnitAssignment
|
|
struct IfcUnitAssignment : ObjectHelper<IfcUnitAssignment,1> { IfcUnitAssignment() : Object("IfcUnitAssignment") {}
|
|
ListOf< IfcUnit, 1, 0 >::Out Units;
|
|
};
|
|
|
|
// C++ wrapper for IfcUnitaryEquipmentType
|
|
struct IfcUnitaryEquipmentType : IfcEnergyConversionDeviceType, ObjectHelper<IfcUnitaryEquipmentType,1> { IfcUnitaryEquipmentType() : Object("IfcUnitaryEquipmentType") {}
|
|
IfcUnitaryEquipmentTypeEnum::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 IfcVibrationIsolatorType
|
|
struct IfcVibrationIsolatorType : IfcDiscreteAccessoryType, 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 IfcWall
|
|
struct IfcWall : IfcBuildingElement, ObjectHelper<IfcWall,0> { IfcWall() : Object("IfcWall") {}
|
|
|
|
};
|
|
|
|
// 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 IfcWasteTerminalType
|
|
struct IfcWasteTerminalType : IfcFlowTerminalType, ObjectHelper<IfcWasteTerminalType,1> { IfcWasteTerminalType() : Object("IfcWasteTerminalType") {}
|
|
IfcWasteTerminalTypeEnum::Out PredefinedType;
|
|
};
|
|
|
|
// C++ wrapper for IfcWindow
|
|
struct IfcWindow : IfcBuildingElement, ObjectHelper<IfcWindow,2> { IfcWindow() : Object("IfcWindow") {}
|
|
Maybe< IfcPositiveLengthMeasure::Out > OverallHeight;
|
|
Maybe< IfcPositiveLengthMeasure::Out > OverallWidth;
|
|
};
|
|
|
|
// C++ wrapper for IfcWindowStyle
|
|
struct IfcWindowStyle : IfcTypeProduct, ObjectHelper<IfcWindowStyle,4> { IfcWindowStyle() : Object("IfcWindowStyle") {}
|
|
IfcWindowStyleConstructionEnum::Out ConstructionType;
|
|
IfcWindowStyleOperationEnum::Out OperationType;
|
|
BOOLEAN::Out ParameterTakesPrecedence;
|
|
BOOLEAN::Out Sizeable;
|
|
};
|
|
|
|
// C++ wrapper for IfcWorkControl
|
|
struct IfcWorkControl : IfcControl, ObjectHelper<IfcWorkControl,10> { IfcWorkControl() : Object("IfcWorkControl") {}
|
|
IfcIdentifier::Out Identifier;
|
|
IfcDateTimeSelect::Out CreationDate;
|
|
Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > Creators;
|
|
Maybe< IfcLabel::Out > Purpose;
|
|
Maybe< IfcTimeMeasure::Out > Duration;
|
|
Maybe< IfcTimeMeasure::Out > TotalFloat;
|
|
IfcDateTimeSelect::Out StartTime;
|
|
Maybe< IfcDateTimeSelect::Out > FinishTime;
|
|
Maybe< IfcWorkControlTypeEnum::Out > WorkControlType;
|
|
Maybe< IfcLabel::Out > UserDefinedControlType;
|
|
};
|
|
|
|
// C++ wrapper for IfcWorkPlan
|
|
struct IfcWorkPlan : IfcWorkControl, ObjectHelper<IfcWorkPlan,0> { IfcWorkPlan() : Object("IfcWorkPlan") {}
|
|
|
|
};
|
|
|
|
// C++ wrapper for IfcWorkSchedule
|
|
struct IfcWorkSchedule : IfcWorkControl, ObjectHelper<IfcWorkSchedule,0> { IfcWorkSchedule() : Object("IfcWorkSchedule") {}
|
|
|
|
};
|
|
|
|
// 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< IfcPositiveLengthMeasure::Out > FilletRadius;
|
|
Maybe< IfcPositiveLengthMeasure::Out > EdgeRadius;
|
|
};
|
|
|
|
// C++ wrapper for IfcZone
|
|
struct IfcZone : IfcGroup, ObjectHelper<IfcZone,0> { IfcZone() : Object("IfcZone") {}
|
|
|
|
};
|
|
|
|
void GetSchema(EXPRESS::ConversionSchema& out);
|
|
|
|
} //! IFC
|
|
namespace STEP {
|
|
|
|
// ******************************************************************************
|
|
// Converter stubs
|
|
// ******************************************************************************
|
|
|
|
#define DECL_CONV_STUB(type) template <> size_t GenericFill<IFC::type>(const STEP::DB& db, const EXPRESS::LIST& params, IFC::type* in)
|
|
|
|
DECL_CONV_STUB(IfcRepresentationItem);
|
|
DECL_CONV_STUB(IfcGeometricRepresentationItem);
|
|
DECL_CONV_STUB(IfcCurve);
|
|
DECL_CONV_STUB(IfcBoundedCurve);
|
|
DECL_CONV_STUB(IfcCompositeCurve);
|
|
DECL_CONV_STUB(Ifc2DCompositeCurve);
|
|
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(IfcTypeObject);
|
|
DECL_CONV_STUB(IfcTypeProduct);
|
|
DECL_CONV_STUB(IfcElementType);
|
|
DECL_CONV_STUB(IfcDistributionElementType);
|
|
DECL_CONV_STUB(IfcDistributionControlElementType);
|
|
DECL_CONV_STUB(IfcActuatorType);
|
|
DECL_CONV_STUB(IfcDistributionFlowElementType);
|
|
DECL_CONV_STUB(IfcFlowControllerType);
|
|
DECL_CONV_STUB(IfcAirTerminalBoxType);
|
|
DECL_CONV_STUB(IfcFlowTerminalType);
|
|
DECL_CONV_STUB(IfcAirTerminalType);
|
|
DECL_CONV_STUB(IfcEnergyConversionDeviceType);
|
|
DECL_CONV_STUB(IfcAirToAirHeatRecoveryType);
|
|
DECL_CONV_STUB(IfcAlarmType);
|
|
DECL_CONV_STUB(IfcDraughtingCallout);
|
|
DECL_CONV_STUB(IfcDimensionCurveDirectedCallout);
|
|
DECL_CONV_STUB(IfcAngularDimension);
|
|
DECL_CONV_STUB(IfcProduct);
|
|
DECL_CONV_STUB(IfcAnnotation);
|
|
DECL_CONV_STUB(IfcStyledItem);
|
|
DECL_CONV_STUB(IfcAnnotationOccurrence);
|
|
DECL_CONV_STUB(IfcAnnotationCurveOccurrence);
|
|
DECL_CONV_STUB(IfcAnnotationFillArea);
|
|
DECL_CONV_STUB(IfcAnnotationFillAreaOccurrence);
|
|
DECL_CONV_STUB(IfcAnnotationSurface);
|
|
DECL_CONV_STUB(IfcAnnotationSurfaceOccurrence);
|
|
DECL_CONV_STUB(IfcAnnotationSymbolOccurrence);
|
|
DECL_CONV_STUB(IfcAnnotationTextOccurrence);
|
|
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(IfcIShapeProfileDef);
|
|
DECL_CONV_STUB(IfcAsymmetricIShapeProfileDef);
|
|
DECL_CONV_STUB(IfcPlacement);
|
|
DECL_CONV_STUB(IfcAxis1Placement);
|
|
DECL_CONV_STUB(IfcAxis2Placement2D);
|
|
DECL_CONV_STUB(IfcAxis2Placement3D);
|
|
DECL_CONV_STUB(IfcBSplineCurve);
|
|
DECL_CONV_STUB(IfcElement);
|
|
DECL_CONV_STUB(IfcBuildingElement);
|
|
DECL_CONV_STUB(IfcBeam);
|
|
DECL_CONV_STUB(IfcBuildingElementType);
|
|
DECL_CONV_STUB(IfcBeamType);
|
|
DECL_CONV_STUB(IfcBezierCurve);
|
|
DECL_CONV_STUB(IfcCsgPrimitive3D);
|
|
DECL_CONV_STUB(IfcBlock);
|
|
DECL_CONV_STUB(IfcBoilerType);
|
|
DECL_CONV_STUB(IfcBooleanResult);
|
|
DECL_CONV_STUB(IfcBooleanClippingResult);
|
|
DECL_CONV_STUB(IfcSurface);
|
|
DECL_CONV_STUB(IfcBoundedSurface);
|
|
DECL_CONV_STUB(IfcBoundingBox);
|
|
DECL_CONV_STUB(IfcHalfSpaceSolid);
|
|
DECL_CONV_STUB(IfcBoxedHalfSpace);
|
|
DECL_CONV_STUB(IfcSpatialStructureElement);
|
|
DECL_CONV_STUB(IfcBuilding);
|
|
DECL_CONV_STUB(IfcBuildingElementComponent);
|
|
DECL_CONV_STUB(IfcBuildingElementPart);
|
|
DECL_CONV_STUB(IfcBuildingElementProxy);
|
|
DECL_CONV_STUB(IfcBuildingElementProxyType);
|
|
DECL_CONV_STUB(IfcBuildingStorey);
|
|
DECL_CONV_STUB(IfcCShapeProfileDef);
|
|
DECL_CONV_STUB(IfcFlowFittingType);
|
|
DECL_CONV_STUB(IfcCableCarrierFittingType);
|
|
DECL_CONV_STUB(IfcFlowSegmentType);
|
|
DECL_CONV_STUB(IfcCableCarrierSegmentType);
|
|
DECL_CONV_STUB(IfcCableSegmentType);
|
|
DECL_CONV_STUB(IfcPoint);
|
|
DECL_CONV_STUB(IfcCartesianPoint);
|
|
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(IfcFeatureElement);
|
|
DECL_CONV_STUB(IfcFeatureElementSubtraction);
|
|
DECL_CONV_STUB(IfcEdgeFeature);
|
|
DECL_CONV_STUB(IfcChamferEdgeFeature);
|
|
DECL_CONV_STUB(IfcChillerType);
|
|
DECL_CONV_STUB(IfcConic);
|
|
DECL_CONV_STUB(IfcCircle);
|
|
DECL_CONV_STUB(IfcCircleProfileDef);
|
|
DECL_CONV_STUB(IfcCircleHollowProfileDef);
|
|
DECL_CONV_STUB(IfcTopologicalRepresentationItem);
|
|
DECL_CONV_STUB(IfcConnectedFaceSet);
|
|
DECL_CONV_STUB(IfcClosedShell);
|
|
DECL_CONV_STUB(IfcCoilType);
|
|
DECL_CONV_STUB(IfcColourSpecification);
|
|
DECL_CONV_STUB(IfcColourRgb);
|
|
DECL_CONV_STUB(IfcColumn);
|
|
DECL_CONV_STUB(IfcColumnType);
|
|
DECL_CONV_STUB(IfcProperty);
|
|
DECL_CONV_STUB(IfcComplexProperty);
|
|
DECL_CONV_STUB(IfcCompositeCurveSegment);
|
|
DECL_CONV_STUB(IfcCompositeProfileDef);
|
|
DECL_CONV_STUB(IfcFlowMovingDeviceType);
|
|
DECL_CONV_STUB(IfcCompressorType);
|
|
DECL_CONV_STUB(IfcCondenserType);
|
|
DECL_CONV_STUB(IfcCondition);
|
|
DECL_CONV_STUB(IfcConditionCriterion);
|
|
DECL_CONV_STUB(IfcResource);
|
|
DECL_CONV_STUB(IfcConstructionResource);
|
|
DECL_CONV_STUB(IfcConstructionEquipmentResource);
|
|
DECL_CONV_STUB(IfcConstructionMaterialResource);
|
|
DECL_CONV_STUB(IfcConstructionProductResource);
|
|
DECL_CONV_STUB(IfcNamedUnit);
|
|
DECL_CONV_STUB(IfcContextDependentUnit);
|
|
DECL_CONV_STUB(IfcControllerType);
|
|
DECL_CONV_STUB(IfcConversionBasedUnit);
|
|
DECL_CONV_STUB(IfcCooledBeamType);
|
|
DECL_CONV_STUB(IfcCoolingTowerType);
|
|
DECL_CONV_STUB(IfcCostItem);
|
|
DECL_CONV_STUB(IfcCostSchedule);
|
|
DECL_CONV_STUB(IfcCovering);
|
|
DECL_CONV_STUB(IfcCoveringType);
|
|
DECL_CONV_STUB(IfcCraneRailAShapeProfileDef);
|
|
DECL_CONV_STUB(IfcCraneRailFShapeProfileDef);
|
|
DECL_CONV_STUB(IfcCrewResource);
|
|
DECL_CONV_STUB(IfcSolidModel);
|
|
DECL_CONV_STUB(IfcCsgSolid);
|
|
DECL_CONV_STUB(IfcCurtainWall);
|
|
DECL_CONV_STUB(IfcCurtainWallType);
|
|
DECL_CONV_STUB(IfcCurveBoundedPlane);
|
|
DECL_CONV_STUB(IfcPresentationStyle);
|
|
DECL_CONV_STUB(IfcDamperType);
|
|
DECL_CONV_STUB(IfcDefinedSymbol);
|
|
DECL_CONV_STUB(IfcDerivedProfileDef);
|
|
DECL_CONV_STUB(IfcDiameterDimension);
|
|
DECL_CONV_STUB(IfcDimensionCurve);
|
|
DECL_CONV_STUB(IfcTerminatorSymbol);
|
|
DECL_CONV_STUB(IfcDimensionCurveTerminator);
|
|
DECL_CONV_STUB(IfcDirection);
|
|
DECL_CONV_STUB(IfcElementComponent);
|
|
DECL_CONV_STUB(IfcDiscreteAccessory);
|
|
DECL_CONV_STUB(IfcElementComponentType);
|
|
DECL_CONV_STUB(IfcDiscreteAccessoryType);
|
|
DECL_CONV_STUB(IfcDistributionElement);
|
|
DECL_CONV_STUB(IfcDistributionFlowElement);
|
|
DECL_CONV_STUB(IfcDistributionChamberElement);
|
|
DECL_CONV_STUB(IfcDistributionChamberElementType);
|
|
DECL_CONV_STUB(IfcDistributionControlElement);
|
|
DECL_CONV_STUB(IfcPort);
|
|
DECL_CONV_STUB(IfcDistributionPort);
|
|
DECL_CONV_STUB(IfcDoor);
|
|
DECL_CONV_STUB(IfcPropertyDefinition);
|
|
DECL_CONV_STUB(IfcPropertySetDefinition);
|
|
DECL_CONV_STUB(IfcDoorStyle);
|
|
DECL_CONV_STUB(IfcDuctFittingType);
|
|
DECL_CONV_STUB(IfcDuctSegmentType);
|
|
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(IfcElectricApplianceType);
|
|
DECL_CONV_STUB(IfcFlowController);
|
|
DECL_CONV_STUB(IfcElectricDistributionPoint);
|
|
DECL_CONV_STUB(IfcFlowStorageDeviceType);
|
|
DECL_CONV_STUB(IfcElectricFlowStorageDeviceType);
|
|
DECL_CONV_STUB(IfcElectricGeneratorType);
|
|
DECL_CONV_STUB(IfcElectricHeaterType);
|
|
DECL_CONV_STUB(IfcElectricMotorType);
|
|
DECL_CONV_STUB(IfcElectricTimeControlType);
|
|
DECL_CONV_STUB(IfcSystem);
|
|
DECL_CONV_STUB(IfcElectricalCircuit);
|
|
DECL_CONV_STUB(IfcElectricalElement);
|
|
DECL_CONV_STUB(IfcElementAssembly);
|
|
DECL_CONV_STUB(IfcElementQuantity);
|
|
DECL_CONV_STUB(IfcElementarySurface);
|
|
DECL_CONV_STUB(IfcEllipse);
|
|
DECL_CONV_STUB(IfcEllipseProfileDef);
|
|
DECL_CONV_STUB(IfcEnergyConversionDevice);
|
|
DECL_CONV_STUB(IfcEquipmentElement);
|
|
DECL_CONV_STUB(IfcEquipmentStandard);
|
|
DECL_CONV_STUB(IfcEvaporativeCoolerType);
|
|
DECL_CONV_STUB(IfcEvaporatorType);
|
|
DECL_CONV_STUB(IfcSweptAreaSolid);
|
|
DECL_CONV_STUB(IfcExtrudedAreaSolid);
|
|
DECL_CONV_STUB(IfcFace);
|
|
DECL_CONV_STUB(IfcFaceBasedSurfaceModel);
|
|
DECL_CONV_STUB(IfcFaceBound);
|
|
DECL_CONV_STUB(IfcFaceOuterBound);
|
|
DECL_CONV_STUB(IfcFaceSurface);
|
|
DECL_CONV_STUB(IfcManifoldSolidBrep);
|
|
DECL_CONV_STUB(IfcFacetedBrep);
|
|
DECL_CONV_STUB(IfcFacetedBrepWithVoids);
|
|
DECL_CONV_STUB(IfcFanType);
|
|
DECL_CONV_STUB(IfcFastener);
|
|
DECL_CONV_STUB(IfcFastenerType);
|
|
DECL_CONV_STUB(IfcFeatureElementAddition);
|
|
DECL_CONV_STUB(IfcFillAreaStyleHatching);
|
|
DECL_CONV_STUB(IfcFillAreaStyleTileSymbolWithStyle);
|
|
DECL_CONV_STUB(IfcFillAreaStyleTiles);
|
|
DECL_CONV_STUB(IfcFilterType);
|
|
DECL_CONV_STUB(IfcFireSuppressionTerminalType);
|
|
DECL_CONV_STUB(IfcFlowFitting);
|
|
DECL_CONV_STUB(IfcFlowInstrumentType);
|
|
DECL_CONV_STUB(IfcFlowMeterType);
|
|
DECL_CONV_STUB(IfcFlowMovingDevice);
|
|
DECL_CONV_STUB(IfcFlowSegment);
|
|
DECL_CONV_STUB(IfcFlowStorageDevice);
|
|
DECL_CONV_STUB(IfcFlowTerminal);
|
|
DECL_CONV_STUB(IfcFlowTreatmentDevice);
|
|
DECL_CONV_STUB(IfcFooting);
|
|
DECL_CONV_STUB(IfcFurnishingElement);
|
|
DECL_CONV_STUB(IfcFurnishingElementType);
|
|
DECL_CONV_STUB(IfcFurnitureStandard);
|
|
DECL_CONV_STUB(IfcFurnitureType);
|
|
DECL_CONV_STUB(IfcGasTerminalType);
|
|
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(IfcHeatExchangerType);
|
|
DECL_CONV_STUB(IfcHumidifierType);
|
|
DECL_CONV_STUB(IfcInventory);
|
|
DECL_CONV_STUB(IfcJunctionBoxType);
|
|
DECL_CONV_STUB(IfcLShapeProfileDef);
|
|
DECL_CONV_STUB(IfcLaborResource);
|
|
DECL_CONV_STUB(IfcLampType);
|
|
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(IfcLinearDimension);
|
|
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(IfcMember);
|
|
DECL_CONV_STUB(IfcMemberType);
|
|
DECL_CONV_STUB(IfcMotorConnectionType);
|
|
DECL_CONV_STUB(IfcProcess);
|
|
DECL_CONV_STUB(IfcTask);
|
|
DECL_CONV_STUB(IfcMove);
|
|
DECL_CONV_STUB(IfcOccupant);
|
|
DECL_CONV_STUB(IfcOffsetCurve2D);
|
|
DECL_CONV_STUB(IfcOffsetCurve3D);
|
|
DECL_CONV_STUB(IfcOneDirectionRepeatFactor);
|
|
DECL_CONV_STUB(IfcOpenShell);
|
|
DECL_CONV_STUB(IfcOpeningElement);
|
|
DECL_CONV_STUB(IfcOrderAction);
|
|
DECL_CONV_STUB(IfcOrientedEdge);
|
|
DECL_CONV_STUB(IfcOutletType);
|
|
DECL_CONV_STUB(IfcPath);
|
|
DECL_CONV_STUB(IfcPerformanceHistory);
|
|
DECL_CONV_STUB(IfcPermit);
|
|
DECL_CONV_STUB(IfcPile);
|
|
DECL_CONV_STUB(IfcPipeFittingType);
|
|
DECL_CONV_STUB(IfcPipeSegmentType);
|
|
DECL_CONV_STUB(IfcPlanarExtent);
|
|
DECL_CONV_STUB(IfcPlanarBox);
|
|
DECL_CONV_STUB(IfcPlane);
|
|
DECL_CONV_STUB(IfcPlate);
|
|
DECL_CONV_STUB(IfcPlateType);
|
|
DECL_CONV_STUB(IfcPointOnCurve);
|
|
DECL_CONV_STUB(IfcPointOnSurface);
|
|
DECL_CONV_STUB(IfcPolyLoop);
|
|
DECL_CONV_STUB(IfcPolygonalBoundedHalfSpace);
|
|
DECL_CONV_STUB(IfcPolyline);
|
|
DECL_CONV_STUB(IfcPresentationStyleAssignment);
|
|
DECL_CONV_STUB(IfcProcedure);
|
|
DECL_CONV_STUB(IfcProductDefinitionShape);
|
|
DECL_CONV_STUB(IfcProject);
|
|
DECL_CONV_STUB(IfcProjectOrder);
|
|
DECL_CONV_STUB(IfcProjectOrderRecord);
|
|
DECL_CONV_STUB(IfcProjectionCurve);
|
|
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(IfcProtectiveDeviceType);
|
|
DECL_CONV_STUB(IfcProxy);
|
|
DECL_CONV_STUB(IfcPumpType);
|
|
DECL_CONV_STUB(IfcRadiusDimension);
|
|
DECL_CONV_STUB(IfcRailing);
|
|
DECL_CONV_STUB(IfcRailingType);
|
|
DECL_CONV_STUB(IfcRamp);
|
|
DECL_CONV_STUB(IfcRampFlight);
|
|
DECL_CONV_STUB(IfcRampFlightType);
|
|
DECL_CONV_STUB(IfcRationalBezierCurve);
|
|
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(IfcReinforcingMesh);
|
|
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(IfcRelOverridesProperties);
|
|
DECL_CONV_STUB(IfcRelVoidsElement);
|
|
DECL_CONV_STUB(IfcRepresentation);
|
|
DECL_CONV_STUB(IfcRepresentationMap);
|
|
DECL_CONV_STUB(IfcRevolvedAreaSolid);
|
|
DECL_CONV_STUB(IfcRightCircularCone);
|
|
DECL_CONV_STUB(IfcRightCircularCylinder);
|
|
DECL_CONV_STUB(IfcRoof);
|
|
DECL_CONV_STUB(IfcRoundedEdgeFeature);
|
|
DECL_CONV_STUB(IfcRoundedRectangleProfileDef);
|
|
DECL_CONV_STUB(IfcSIUnit);
|
|
DECL_CONV_STUB(IfcSanitaryTerminalType);
|
|
DECL_CONV_STUB(IfcScheduleTimeControl);
|
|
DECL_CONV_STUB(IfcSectionedSpine);
|
|
DECL_CONV_STUB(IfcSensorType);
|
|
DECL_CONV_STUB(IfcServiceLife);
|
|
DECL_CONV_STUB(IfcShapeModel);
|
|
DECL_CONV_STUB(IfcShapeRepresentation);
|
|
DECL_CONV_STUB(IfcShellBasedSurfaceModel);
|
|
DECL_CONV_STUB(IfcSite);
|
|
DECL_CONV_STUB(IfcSlab);
|
|
DECL_CONV_STUB(IfcSlabType);
|
|
DECL_CONV_STUB(IfcSpace);
|
|
DECL_CONV_STUB(IfcSpaceHeaterType);
|
|
DECL_CONV_STUB(IfcSpaceProgram);
|
|
DECL_CONV_STUB(IfcSpatialStructureElementType);
|
|
DECL_CONV_STUB(IfcSpaceType);
|
|
DECL_CONV_STUB(IfcSphere);
|
|
DECL_CONV_STUB(IfcStackTerminalType);
|
|
DECL_CONV_STUB(IfcStair);
|
|
DECL_CONV_STUB(IfcStairFlight);
|
|
DECL_CONV_STUB(IfcStairFlightType);
|
|
DECL_CONV_STUB(IfcStructuralActivity);
|
|
DECL_CONV_STUB(IfcStructuralAction);
|
|
DECL_CONV_STUB(IfcStructuralAnalysisModel);
|
|
DECL_CONV_STUB(IfcStructuralItem);
|
|
DECL_CONV_STUB(IfcStructuralConnection);
|
|
DECL_CONV_STUB(IfcStructuralCurveConnection);
|
|
DECL_CONV_STUB(IfcStructuralMember);
|
|
DECL_CONV_STUB(IfcStructuralCurveMember);
|
|
DECL_CONV_STUB(IfcStructuralCurveMemberVarying);
|
|
DECL_CONV_STUB(IfcStructuralLinearAction);
|
|
DECL_CONV_STUB(IfcStructuralLinearActionVarying);
|
|
DECL_CONV_STUB(IfcStructuralLoadGroup);
|
|
DECL_CONV_STUB(IfcStructuralPlanarAction);
|
|
DECL_CONV_STUB(IfcStructuralPlanarActionVarying);
|
|
DECL_CONV_STUB(IfcStructuralPointAction);
|
|
DECL_CONV_STUB(IfcStructuralPointConnection);
|
|
DECL_CONV_STUB(IfcStructuralReaction);
|
|
DECL_CONV_STUB(IfcStructuralPointReaction);
|
|
DECL_CONV_STUB(IfcStructuralResultGroup);
|
|
DECL_CONV_STUB(IfcStructuralSurfaceConnection);
|
|
DECL_CONV_STUB(IfcStructuralSurfaceMember);
|
|
DECL_CONV_STUB(IfcStructuralSurfaceMemberVarying);
|
|
DECL_CONV_STUB(IfcStructuredDimensionCallout);
|
|
DECL_CONV_STUB(IfcStyleModel);
|
|
DECL_CONV_STUB(IfcStyledRepresentation);
|
|
DECL_CONV_STUB(IfcSubContractResource);
|
|
DECL_CONV_STUB(IfcSubedge);
|
|
DECL_CONV_STUB(IfcSurfaceCurveSweptAreaSolid);
|
|
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(IfcSwitchingDeviceType);
|
|
DECL_CONV_STUB(IfcSystemFurnitureElementType);
|
|
DECL_CONV_STUB(IfcTShapeProfileDef);
|
|
DECL_CONV_STUB(IfcTankType);
|
|
DECL_CONV_STUB(IfcTendon);
|
|
DECL_CONV_STUB(IfcTendonAnchor);
|
|
DECL_CONV_STUB(IfcTextLiteral);
|
|
DECL_CONV_STUB(IfcTextLiteralWithExtent);
|
|
DECL_CONV_STUB(IfcTimeSeriesSchedule);
|
|
DECL_CONV_STUB(IfcTopologyRepresentation);
|
|
DECL_CONV_STUB(IfcTransformerType);
|
|
DECL_CONV_STUB(IfcTransportElement);
|
|
DECL_CONV_STUB(IfcTransportElementType);
|
|
DECL_CONV_STUB(IfcTrapeziumProfileDef);
|
|
DECL_CONV_STUB(IfcTrimmedCurve);
|
|
DECL_CONV_STUB(IfcTubeBundleType);
|
|
DECL_CONV_STUB(IfcTwoDirectionRepeatFactor);
|
|
DECL_CONV_STUB(IfcUShapeProfileDef);
|
|
DECL_CONV_STUB(IfcUnitAssignment);
|
|
DECL_CONV_STUB(IfcUnitaryEquipmentType);
|
|
DECL_CONV_STUB(IfcValveType);
|
|
DECL_CONV_STUB(IfcVector);
|
|
DECL_CONV_STUB(IfcVertex);
|
|
DECL_CONV_STUB(IfcVertexLoop);
|
|
DECL_CONV_STUB(IfcVertexPoint);
|
|
DECL_CONV_STUB(IfcVibrationIsolatorType);
|
|
DECL_CONV_STUB(IfcVirtualElement);
|
|
DECL_CONV_STUB(IfcWall);
|
|
DECL_CONV_STUB(IfcWallStandardCase);
|
|
DECL_CONV_STUB(IfcWallType);
|
|
DECL_CONV_STUB(IfcWasteTerminalType);
|
|
DECL_CONV_STUB(IfcWindow);
|
|
DECL_CONV_STUB(IfcWindowStyle);
|
|
DECL_CONV_STUB(IfcWorkControl);
|
|
DECL_CONV_STUB(IfcWorkPlan);
|
|
DECL_CONV_STUB(IfcWorkSchedule);
|
|
DECL_CONV_STUB(IfcZShapeProfileDef);
|
|
DECL_CONV_STUB(IfcZone);
|
|
|
|
|
|
#undef DECL_CONV_STUB
|
|
|
|
} //! STEP
|
|
} //! Assimp
|
|
|
|
#endif // INCLUDED_IFC_READER_GEN_H
|