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