/////////////////////////////////////////////////////////////////////////////// // Copyright (C) 2002-2025, Open Design Alliance (the "Alliance"). // All rights reserved. // // This software and its documentation and related materials are owned by // the Alliance. The software may only be incorporated into application // programs owned by members of the Alliance, subject to a signed // Membership Agreement and Supplemental Software License Agreement with the // Alliance. The structure and organization of this software are the valuable // trade secrets of the Alliance and its suppliers. The software is also // protected by copyright law and international treaty provisions. Application // programs incorporating this software must include the following statement // with their copyright notices: // // This application incorporates Open Design Alliance software pursuant to a license // agreement with Open Design Alliance. // Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance. // All rights reserved. // // By use of this software, its documentation or related materials, you // acknowledge and accept the above terms. /////////////////////////////////////////////////////////////////////////////// // This file is generated automatically. #ifndef _IFC2X_FINAL_ENUM_H #define _IFC2X_FINAL_ENUM_H #include "RxValue.h" #include "daiEnum.h" #include "Ifc2x_FinalBuildOption.h" #include "TD_PackPush.h" namespace OdIfc2x_final { /** \details This enumeration defines roles which may be played by an actor. */ enum IfcRoleEnum { /** Supplier*/ kIfcRoleEnum_SUPPLIER, /** Manufacturer*/ kIfcRoleEnum_MANUFACTURER, /** Contractor*/ kIfcRoleEnum_CONTRACTOR, /** Sub-contractor*/ kIfcRoleEnum_SUBCONTRACTOR, /** Architect*/ kIfcRoleEnum_ARCHITECT, /** Structural engineer*/ kIfcRoleEnum_STRUCTURALENGINEER, /** Cost engineer*/ kIfcRoleEnum_COSTENGINEER, /** Client*/ kIfcRoleEnum_CLIENT, /** Facility owner*/ kIfcRoleEnum_BUILDINGOWNER, /** Facility operator*/ kIfcRoleEnum_BUILDINGOPERATOR, /** Mechanical engineer*/ kIfcRoleEnum_MECHANICALENGINEER, /** Electrical engineer*/ kIfcRoleEnum_ELECTRICALENGINEER, /** Project manager*/ kIfcRoleEnum_PROJECTMANAGER, /** Facilities manager*/ kIfcRoleEnum_FACILITIESMANAGER, /** Civil engineer*/ kIfcRoleEnum_CIVILENGINEER, /** Commissioning engineer*/ kIfcRoleEnum_COMISSIONINGENGINEER, /** Engineer*/ kIfcRoleEnum_ENGINEER, /** Owner*/ kIfcRoleEnum_OWNER, /** Consultant*/ kIfcRoleEnum_CONSULTANT, /** Construction manager*/ kIfcRoleEnum_CONSTRUCTIONMANAGER, /** Field construction manager*/ kIfcRoleEnum_FIELDCONSTRUCTIONMANAGER, /** Reseller*/ kIfcRoleEnum_RESELLER, /** User defined value to be provided.*/ kIfcRoleEnum_USERDEFINED, /** The value is unset.*/ kIfcRoleEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcRoleEnum& getUnset() { static OdIfc2x_final::IfcRoleEnum nullEnum = OdIfc2x_final::kIfcRoleEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration identifies the logical location of the address. */ enum IfcAddressTypeEnum { /** An office address.*/ kIfcAddressTypeEnum_OFFICE, /** A site address.*/ kIfcAddressTypeEnum_SITE, /** A home address.*/ kIfcAddressTypeEnum_HOME, /** A postal distribution point address.*/ kIfcAddressTypeEnum_DISTRIBUTIONPOINT, /** A user defined address type to be provided.*/ kIfcAddressTypeEnum_USERDEFINED, /** The value is unset.*/ kIfcAddressTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcAddressTypeEnum& getUnset() { static OdIfc2x_final::IfcAddressTypeEnum nullEnum = OdIfc2x_final::kIfcAddressTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details An enumeration type that is used to specify whether a local time is ahead or behind of the coordinated universal time. */ enum IfcAheadOrBehind { /** The time is ahead of coordinated universal time.*/ kIfcAheadOrBehind_AHEAD, /** The time is behind of coordinated universal time.*/ kIfcAheadOrBehind_BEHIND, /** The value is unset.*/ kIfcAheadOrBehind_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcAheadOrBehind& getUnset() { static OdIfc2x_final::IfcAheadOrBehind nullEnum = OdIfc2x_final::kIfcAheadOrBehind_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details IfcDocumentConfidentialityEnum enables selection of the level of confidentiality of document information from a list of choices. */ enum IfcDocumentConfidentialityEnum { /** Document is publicly available.*/ kIfcDocumentConfidentialityEnum_PUBLIC, /** Document availability is restricted.*/ kIfcDocumentConfidentialityEnum_RESTRICTED, /** Document is confidential and its contents should not be revealed without permission.*/ kIfcDocumentConfidentialityEnum_CONFIDENTIAL, /** Document is personal to the author.*/ kIfcDocumentConfidentialityEnum_PERSONAL, /** Not defined.*/ kIfcDocumentConfidentialityEnum_NOTDEFINED, /** The value is unset.*/ kIfcDocumentConfidentialityEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcDocumentConfidentialityEnum& getUnset() { static OdIfc2x_final::IfcDocumentConfidentialityEnum nullEnum = OdIfc2x_final::kIfcDocumentConfidentialityEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details IfcDocumentStatusEnum enables selection of the status of document information from a list of choices. */ enum IfcDocumentStatusEnum { /** Document is a draft.*/ kIfcDocumentStatusEnum_DRAFT, /** Document is a final draft.*/ kIfcDocumentStatusEnum_FINALDRAFT, /** Document is final.*/ kIfcDocumentStatusEnum_FINAL, /** Document has undergone revision.*/ kIfcDocumentStatusEnum_REVISION, /** Not defined.*/ kIfcDocumentStatusEnum_NOTDEFINED, /** The value is unset.*/ kIfcDocumentStatusEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcDocumentStatusEnum& getUnset() { static OdIfc2x_final::IfcDocumentStatusEnum nullEnum = OdIfc2x_final::kIfcDocumentStatusEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Boolean operators that apply to the first and second Boolean operands. */ enum IfcBooleanOperator { /** The operation of constructing the regularized set theoretic union of the volumes defined by two solids.*/ kIfcBooleanOperator_UNION, /** The operation of constructing the regularized set theoretic intersection of the volumes defined by two solids.*/ kIfcBooleanOperator_INTERSECTION, /** The regularized set theoretic difference between the volumes defined by two solids.*/ kIfcBooleanOperator_DIFFERENCE, /** The value is unset.*/ kIfcBooleanOperator_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcBooleanOperator& getUnset() { static OdIfc2x_final::IfcBooleanOperator nullEnum = OdIfc2x_final::kIfcBooleanOperator_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details The IfcTransitionCode indicated the continuity between consecutive segments of a curve or surface. */ enum IfcTransitionCode { /** The segments do not join. This is permitted only at the boundary of the curve or surface to indicate that it is not closed.*/ kIfcTransitionCode_DISCONTINUOUS, /** The segments join but no condition on their tangents is implied.*/ kIfcTransitionCode_CONTINUOUS, /** The segments join and their tangent vectors or tangent planes are parallel and have the same direction at the joint: equality of derivatives is not required.*/ kIfcTransitionCode_CONTSAMEGRADIENT, /** For a curve, the segments join, their tangent vectors are parallel and in the same direction and their curvatures are equal at the joint: equality of derivatives is not required. For a surface this implies that the principle curvatures are the same and the principle directions are coincident along the common boundary.*/ kIfcTransitionCode_CONTSAMEGRADIENTSAMECURVATURE, /** The value is unset.*/ kIfcTransitionCode_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcTransitionCode& getUnset() { static OdIfc2x_final::IfcTransitionCode nullEnum = OdIfc2x_final::kIfcTransitionCode_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details The IfcTrimmingPreference indicates the preferred way of trimming. */ enum IfcTrimmingPreference { /** Indicates that trimming by Cartesian point is preferred.*/ kIfcTrimmingPreference_CARTESIAN, /** Indicates the preference for the parameter value.*/ kIfcTrimmingPreference_PARAMETER, /** Indicates that no preference is communicated.*/ kIfcTrimmingPreference_UNSPECIFIED, /** The value is unset.*/ kIfcTrimmingPreference_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcTrimmingPreference& getUnset() { static OdIfc2x_final::IfcTrimmingPreference nullEnum = OdIfc2x_final::kIfcTrimmingPreference_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details IfcLayerSetDirectionEnum provides identification of the axis of element geometry, denoting the layer set thickness direction, or direction of layer offsets. */ enum IfcLayerSetDirectionEnum { /** Usually x-axis.*/ kIfcLayerSetDirectionEnum_AXIS1, /** Usually y-axis.*/ kIfcLayerSetDirectionEnum_AXIS2, /** Usually z-axis.*/ kIfcLayerSetDirectionEnum_AXIS3, /** The value is unset.*/ kIfcLayerSetDirectionEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcLayerSetDirectionEnum& getUnset() { static OdIfc2x_final::IfcLayerSetDirectionEnum nullEnum = OdIfc2x_final::kIfcLayerSetDirectionEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details IfcDirectionSenseEnum is an enumeration denoting whether sense of direction is positive or negative along the given axis. */ enum IfcDirectionSenseEnum { /** Direction defined to be positive.*/ kIfcDirectionSenseEnum_POSITIVE, /** Direction defined to be negative.*/ kIfcDirectionSenseEnum_NEGATIVE, /** The value is unset.*/ kIfcDirectionSenseEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcDirectionSenseEnum& getUnset() { static OdIfc2x_final::IfcDirectionSenseEnum nullEnum = OdIfc2x_final::kIfcDirectionSenseEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details [object Object] */ enum IfcSIPrefix { /** 10^18.*/ kIfcSIPrefix_EXA, /** 10^15.*/ kIfcSIPrefix_PETA, /** 10^12.*/ kIfcSIPrefix_TERA, /** 10^9.*/ kIfcSIPrefix_GIGA, /** 10^6.*/ kIfcSIPrefix_MEGA, /** 10^3.*/ kIfcSIPrefix_KILO, /** 10^2.*/ kIfcSIPrefix_HECTO, /** 10.*/ kIfcSIPrefix_DECA, /** 10^-1.*/ kIfcSIPrefix_DECI, /** 10^-2.*/ kIfcSIPrefix_CENTI, /** 10^-3.*/ kIfcSIPrefix_MILLI, /** 10^-6.*/ kIfcSIPrefix_MICRO, /** 10^-9.*/ kIfcSIPrefix_NANO, /** 10^-12.*/ kIfcSIPrefix_PICO, /** 10^-15.*/ kIfcSIPrefix_FEMTO, /** 10^-18.*/ kIfcSIPrefix_ATTO, /** The value is unset.*/ kIfcSIPrefix_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcSIPrefix& getUnset() { static OdIfc2x_final::IfcSIPrefix nullEnum = OdIfc2x_final::kIfcSIPrefix_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details [object Object] */ enum IfcSIUnitName { /** Unit for electric current.*/ kIfcSIUnitName_AMPERE, /** Unit for radioactivity.*/ kIfcSIUnitName_BECQUEREL, /** Unit for luminousintensity.*/ kIfcSIUnitName_CANDELA, /** Unit for electric charge.*/ kIfcSIUnitName_COULOMB, /** Unit for volume.*/ kIfcSIUnitName_CUBIC_METRE, /** Unit for thermodynamic temperature.*/ kIfcSIUnitName_DEGREE_CELSIUS, /** Unit for electric capacitance.*/ kIfcSIUnitName_FARAD, /** Unit for mass.*/ kIfcSIUnitName_GRAM, /** Unit for absorbed radioactive dose.*/ kIfcSIUnitName_GRAY, /** Unit for inductance.*/ kIfcSIUnitName_HENRY, /** Unit for frequency.*/ kIfcSIUnitName_HERTZ, /** Unit for energy.*/ kIfcSIUnitName_JOULE, /** Unit for thermodynamic temperature.*/ kIfcSIUnitName_KELVIN, /** Unit for luminous flux.*/ kIfcSIUnitName_LUMEN, /** Unit for illuminance.*/ kIfcSIUnitName_LUX, /** Unit for length.*/ kIfcSIUnitName_METRE, /** Unit for amount of substance.*/ kIfcSIUnitName_MOLE, /** Unit for force.*/ kIfcSIUnitName_NEWTON, /** Unit for electric resistance.*/ kIfcSIUnitName_OHM, /** Unit for pressure.*/ kIfcSIUnitName_PASCAL, /** Unit for plane angle.*/ kIfcSIUnitName_RADIAN, /** Unit for time.*/ kIfcSIUnitName_SECOND, /** Unit for electric conductance.*/ kIfcSIUnitName_SIEMENS, /** Unit for radioactive dose equivalent.*/ kIfcSIUnitName_SIEVERT, /** Unit for area.*/ kIfcSIUnitName_SQUARE_METRE, /** Unit for solid angle.*/ kIfcSIUnitName_STERADIAN, /** Unit for magnetic flux density.*/ kIfcSIUnitName_TESLA, /** Unit for electric voltage.*/ kIfcSIUnitName_VOLT, /** Unit for power.*/ kIfcSIUnitName_WATT, /** Unit for magnetic flux.*/ kIfcSIUnitName_WEBER, /** The value is unset.*/ kIfcSIUnitName_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcSIUnitName& getUnset() { static OdIfc2x_final::IfcSIUnitName nullEnum = OdIfc2x_final::kIfcSIUnitName_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details IfcUnitEnum is an enumeration type for allowed unit types of IfcNamedUnit. */ enum IfcUnitEnum { /** Absorbed dose unit*/ kIfcUnitEnum_ABSORBEDDOSEUNIT, /** Amount of substance unit*/ kIfcUnitEnum_AMOUNTOFSUBSTANCEUNIT, /** Area unit*/ kIfcUnitEnum_AREAUNIT, /** Dose equivalent unit*/ kIfcUnitEnum_DOSEEQUIVALENTUNIT, /** Electric capacitance unit*/ kIfcUnitEnum_ELECTRICCAPACITANCEUNIT, /** Electric charge unit*/ kIfcUnitEnum_ELECTRICCHARGEUNIT, /** Electric conductance unit*/ kIfcUnitEnum_ELECTRICCONDUCTANCEUNIT, /** Electric current unit*/ kIfcUnitEnum_ELECTRICCURRENTUNIT, /** Electric resistance unit*/ kIfcUnitEnum_ELECTRICRESISTANCEUNIT, /** Electric voltage unit*/ kIfcUnitEnum_ELECTRICVOLTAGEUNIT, /** Energy unit*/ kIfcUnitEnum_ENERGYUNIT, /** Force unit*/ kIfcUnitEnum_FORCEUNIT, /** Frequency unit*/ kIfcUnitEnum_FREQUENCYUNIT, /** Illuminance unit*/ kIfcUnitEnum_ILLUMINANCEUNIT, /** Inductance unit*/ kIfcUnitEnum_INDUCTANCEUNIT, /** Length unit*/ kIfcUnitEnum_LENGTHUNIT, /** Luminous flux unit*/ kIfcUnitEnum_LUMINOUSFLUXUNIT, /** Luminous intensity unit*/ kIfcUnitEnum_LUMINOUSINTENSITYUNIT, /** Magnetic flux density unit*/ kIfcUnitEnum_MAGNETICFLUXDENSITYUNIT, /** Magnetic flux unit*/ kIfcUnitEnum_MAGNETICFLUXUNIT, /** Mass unit*/ kIfcUnitEnum_MASSUNIT, /** Plane angle unit*/ kIfcUnitEnum_PLANEANGLEUNIT, /** Power unit*/ kIfcUnitEnum_POWERUNIT, /** Pressure unit*/ kIfcUnitEnum_PRESSUREUNIT, /** Radio activity unit*/ kIfcUnitEnum_RADIOACTIVITYUNIT, /** Solid angle unit*/ kIfcUnitEnum_SOLIDANGLEUNIT, /** Thermodynamic temperature unit*/ kIfcUnitEnum_THERMODYNAMICTEMPERATUREUNIT, /** Time unit*/ kIfcUnitEnum_TIMEUNIT, /** Volume unit.*/ kIfcUnitEnum_VOLUMEUNIT, /** User defined unit type. The type of unit is only implied by its name or the usage context.*/ kIfcUnitEnum_USERDEFINED, /** The value is unset.*/ kIfcUnitEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcUnitEnum& getUnset() { static OdIfc2x_final::IfcUnitEnum nullEnum = OdIfc2x_final::kIfcUnitEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details IfcDerivedUnitEnum is an enumeration type for allowed types of derived units. */ enum IfcDerivedUnitEnum { /** Angularvelocity unit*/ kIfcDerivedUnitEnum_ANGULARVELOCITYUNIT, /** Compound plane angle unit*/ kIfcDerivedUnitEnum_COMPOUNDPLANEANGLEUNIT, /** Dynamic viscosity unit*/ kIfcDerivedUnitEnum_DYNAMICVISCOSITYUNIT, /** Heat flux density unit*/ kIfcDerivedUnitEnum_HEATFLUXDENSITYUNIT, /** Integer count rate unit*/ kIfcDerivedUnitEnum_INTEGERCOUNTRATEUNIT, /** Isothermal moisture capacity unit*/ kIfcDerivedUnitEnum_ISOTHERMALMOISTURECAPACITYUNIT, /** Kenematic viscosity unit*/ kIfcDerivedUnitEnum_KINEMATICVISCOSITYUNIT, /** Linear velocity unit*/ kIfcDerivedUnitEnum_LINEARVELOCITYUNIT, /** Mass denisity unit*/ kIfcDerivedUnitEnum_MASSDENSITYUNIT, /** Mass flowrate unit*/ kIfcDerivedUnitEnum_MASSFLOWRATEUNIT, /** Moistere diffusivity unit*/ kIfcDerivedUnitEnum_MOISTUREDIFFUSIVITYUNIT, /** Molecular weight unit*/ kIfcDerivedUnitEnum_MOLECULARWEIGHTUNIT, /** Specific heat capacity unit*/ kIfcDerivedUnitEnum_SPECIFICHEATCAPACITYUNIT, /** Thermal admittance unit*/ kIfcDerivedUnitEnum_THERMALADMITTANCEUNIT, /** Thermal Conductance unit*/ kIfcDerivedUnitEnum_THERMALCONDUCTANCEUNIT, /** Thermal resistance unit*/ kIfcDerivedUnitEnum_THERMALRESISTANCEUNIT, /** Thermal transmittance unit*/ kIfcDerivedUnitEnum_THERMALTRANSMITTANCEUNIT, /** Vapor permeability unit*/ kIfcDerivedUnitEnum_VAPORPERMEABILITYUNIT, /** Valumetric flowrate unit*/ kIfcDerivedUnitEnum_VOLUMETRICFLOWRATEUNIT, /** Rotational frequency unit*/ kIfcDerivedUnitEnum_ROTATIONALFREQUENCYUNIT, /** Torque unit*/ kIfcDerivedUnitEnum_TORQUEUNIT, /** MOMENTORINERTIAUNIT.*/ kIfcDerivedUnitEnum_MOMENTORINERTIAUNIT, /** Linear moment unit*/ kIfcDerivedUnitEnum_LINEARMOMENTUNIT, /** Linear force unit*/ kIfcDerivedUnitEnum_LINEARFORCEUNIT, /** planar force unit*/ kIfcDerivedUnitEnum_PLANARFORCEUNIT, /** Modulus of elasticity unit*/ kIfcDerivedUnitEnum_MODULUSOFELASTICITYUNIT, /** Shear modulus unit*/ kIfcDerivedUnitEnum_SHEARMODULUSUNIT, /** Linear stiffness unit*/ kIfcDerivedUnitEnum_LINEARSTIFFNESSUNIT, /** Rotational stuffness unit*/ kIfcDerivedUnitEnum_ROTATIONALSTIFFNESSUNIT, /** Modulus of subgrade reaction unit*/ kIfcDerivedUnitEnum_MODULUSOFSUBGRADEREACTIONUNIT, /** Acceleration unit*/ kIfcDerivedUnitEnum_ACCELERATIONUNIT, /** User defined derived unit.*/ kIfcDerivedUnitEnum_USERDEFINED, /** The value is unset.*/ kIfcDerivedUnitEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcDerivedUnitEnum& getUnset() { static OdIfc2x_final::IfcDerivedUnitEnum nullEnum = OdIfc2x_final::kIfcDerivedUnitEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details An enumeration of the international abbreviations of currencies used of various countries. */ enum IfcCurrencyEnum { /** United Arab Emirates*/ kIfcCurrencyEnum_AED, /** Argentina*/ kIfcCurrencyEnum_AES, /** Austria*/ kIfcCurrencyEnum_ATS, /** Australia*/ kIfcCurrencyEnum_AUD, /** Barbados*/ kIfcCurrencyEnum_BBD, /** Belgium*/ kIfcCurrencyEnum_BEG, /** Bulgaria*/ kIfcCurrencyEnum_BGL, /** Bahrain*/ kIfcCurrencyEnum_BHD, /** Bermuda*/ kIfcCurrencyEnum_BMD, /** Brunei*/ kIfcCurrencyEnum_BND, /** Brazil*/ kIfcCurrencyEnum_BRL, /** Bahamas*/ kIfcCurrencyEnum_BSD, /** Botswana*/ kIfcCurrencyEnum_BWP, /** Belize*/ kIfcCurrencyEnum_BZD, /** Canada*/ kIfcCurrencyEnum_CAD, /** Caribbean*/ kIfcCurrencyEnum_CBD, /** Switzerland*/ kIfcCurrencyEnum_CHF, /** Chile*/ kIfcCurrencyEnum_CLP, /** China*/ kIfcCurrencyEnum_CNY, /** Cyprus*/ kIfcCurrencyEnum_CYS, /** Czech Republic*/ kIfcCurrencyEnum_CZK, /** Dominican Republic*/ kIfcCurrencyEnum_DDP, /** Germany*/ kIfcCurrencyEnum_DEM, /** Denmark*/ kIfcCurrencyEnum_DKK, /** Egypt*/ kIfcCurrencyEnum_EGL, /** Spain*/ kIfcCurrencyEnum_EST, /** [object Object]*/ kIfcCurrencyEnum_EUR, /** Faroe Islands*/ kIfcCurrencyEnum_FAK, /** Finland*/ kIfcCurrencyEnum_FIM, /** Fiji*/ kIfcCurrencyEnum_FJD, /** Falkland Islands*/ kIfcCurrencyEnum_FKP, /** France*/ kIfcCurrencyEnum_FRF, /** United Kingdom*/ kIfcCurrencyEnum_GBP, /** Gibraltar*/ kIfcCurrencyEnum_GIP, /** Gambia*/ kIfcCurrencyEnum_GMD, /** Greece*/ kIfcCurrencyEnum_GRX, /** Hong Kong*/ kIfcCurrencyEnum_HKD, /** Hungary*/ kIfcCurrencyEnum_HUF, /** Iceland*/ kIfcCurrencyEnum_ICK, /** Indonesia*/ kIfcCurrencyEnum_IDR, /** Israel*/ kIfcCurrencyEnum_ILS, /** India*/ kIfcCurrencyEnum_INR, /** Ireland*/ kIfcCurrencyEnum_IRP, /** Italy*/ kIfcCurrencyEnum_ITL, /** Jamaica*/ kIfcCurrencyEnum_JMD, /** Jordan*/ kIfcCurrencyEnum_JOD, /** Japan*/ kIfcCurrencyEnum_JPY, /** Kenya*/ kIfcCurrencyEnum_KES, /** Republic of Korea*/ kIfcCurrencyEnum_KRW, /** Kuwait*/ kIfcCurrencyEnum_KWD, /** Cayman Islands*/ kIfcCurrencyEnum_KYD, /** Sri Lanka*/ kIfcCurrencyEnum_LKR, /** Luxembourg*/ kIfcCurrencyEnum_LUF, /** Malta*/ kIfcCurrencyEnum_MTL, /** Mauritius*/ kIfcCurrencyEnum_MUR, /** Mexico*/ kIfcCurrencyEnum_MXN, /** Malaysia*/ kIfcCurrencyEnum_MYR, /** Netherlands*/ kIfcCurrencyEnum_NLG, /** New Zealand*/ kIfcCurrencyEnum_NZD, /** Oman*/ kIfcCurrencyEnum_OMR, /** Papua New Guinea*/ kIfcCurrencyEnum_PGK, /** Philipines*/ kIfcCurrencyEnum_PHP, /** Pakistan*/ kIfcCurrencyEnum_PKR, /** Poland*/ kIfcCurrencyEnum_PLN, /** Portugal*/ kIfcCurrencyEnum_PTN, /** Qatar*/ kIfcCurrencyEnum_QAR, /** Russia*/ kIfcCurrencyEnum_RUR, /** Saudi Arabia*/ kIfcCurrencyEnum_SAR, /** Seychelles*/ kIfcCurrencyEnum_SCR, /** Sweden*/ kIfcCurrencyEnum_SEK, /** Singapore*/ kIfcCurrencyEnum_SGD, /** St.Helena*/ kIfcCurrencyEnum_SKP, /** Thailand*/ kIfcCurrencyEnum_THB, /** Turkey*/ kIfcCurrencyEnum_TRL, /** Trinidad and Tobago*/ kIfcCurrencyEnum_TTD, /** Taiwan*/ kIfcCurrencyEnum_TWD, /** United States of America*/ kIfcCurrencyEnum_USD, /** Venezuela*/ kIfcCurrencyEnum_VEB, /** Viet-Nam*/ kIfcCurrencyEnum_VND, /** Europe (States of the European Union)*/ kIfcCurrencyEnum_XEU, /** South Africa*/ kIfcCurrencyEnum_ZAR, /** Zimbabwe*/ kIfcCurrencyEnum_ZWD, /** Norway*/ kIfcCurrencyEnum_NOK, /** The value is unset.*/ kIfcCurrencyEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcCurrencyEnum& getUnset() { static OdIfc2x_final::IfcCurrencyEnum nullEnum = OdIfc2x_final::kIfcCurrencyEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details The enumeration defines whether the definition of a profile shape shall be geometrically resolved into a curve or into a surface. */ enum IfcProfileTypeEnum { /** The resulting geometric item is of type curve and closed (with the only exception of the curve created by the IfcArbitraryOpenProfileDef which resolves into an open curve). The resulting geometry after applying a sweeping operation is a swept surface. This can be used to define shapes with thin sheets, such as ducts, where the thickness is not appropriate for geometric representation.*/ kIfcProfileTypeEnum_CURVE, /** The resulting geometric item is of type surface. The resulting geometry after applying a sweeping operation is a swept solid with defined volume.*/ kIfcProfileTypeEnum_AREA, /** The value is unset.*/ kIfcProfileTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcProfileTypeEnum& getUnset() { static OdIfc2x_final::IfcProfileTypeEnum nullEnum = OdIfc2x_final::kIfcProfileTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details The IfcStateEnum enumeration identifies the state or accessibility of the object (for example, read/write, locked). */ enum IfcStateEnum { /** Object is in a Read-Write state. It may be modified by an application.*/ kIfcStateEnum_READWRITE, /** Object is in a Read-Only state. It may be viewed but not modified by an application.*/ kIfcStateEnum_READONLY, /** Object is in a Locked state. It may not be accessed by an application.*/ kIfcStateEnum_LOCKED, /** Object is in a Read-Write-Locked state. It may not be accessed by an application.*/ kIfcStateEnum_READWRITELOCKED, /** Object is in a Read-Only-Locked state. It may not be accessed by an application.*/ kIfcStateEnum_READONLYLOCKED, /** The value is unset.*/ kIfcStateEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcStateEnum& getUnset() { static OdIfc2x_final::IfcStateEnum nullEnum = OdIfc2x_final::kIfcStateEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details IfcChangeActionEnum identifies the type of change that might have occurred to the object during the last session (for example, added, modified, deleted). This information is required in a partial model exchange scenario so that an application or model server will know how an object might have been affected by the previous application. */ enum IfcChangeActionEnum { /** Object has not been modified.*/ kIfcChangeActionEnum_NOCHANGE, /** A modification to the object has been made by the user and application defined by the LastModifyingUser and LastModifyingApplication respectively.*/ kIfcChangeActionEnum_MODIFIED, /** The object has been created by the user and application defined by the OwningUser and OwningApplication respectively.*/ kIfcChangeActionEnum_ADDED, /** The object has been deleted by the user and application defined by the LastModifyingUser and LastModifyingApplication respectively.*/ kIfcChangeActionEnum_DELETED, /** The object has been added and modified by the user and application defined by the LastModifyingUser and LastModifyingApplication respectively.*/ kIfcChangeActionEnum_MODIFIEDADDED, /** The object has been modified and deleted by the user and application defined by the LastModifyingUser and LastModifyingApplication respectively.*/ kIfcChangeActionEnum_MODIFIEDDELETED, /** The value is unset.*/ kIfcChangeActionEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcChangeActionEnum& getUnset() { static OdIfc2x_final::IfcChangeActionEnum nullEnum = OdIfc2x_final::kIfcChangeActionEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details IfcSequenceEnum is an enumeration that defines the different ways in which a time lag is applied to a sequence between two processes. */ enum IfcSequenceEnum { /** The predecessor task must start before the successor task may start.*/ kIfcSequenceEnum_START_START, /** The predecessor task must start before the successor task may finish.*/ kIfcSequenceEnum_START_FINISH, /** The predecessor task must finish before the successor task may start.*/ kIfcSequenceEnum_FINISH_START, /** The predecessor task must finish before the successor task may finish.*/ kIfcSequenceEnum_FINISH_FINISH, /** Undefined.*/ kIfcSequenceEnum_NOTDEFINED, /** The value is unset.*/ kIfcSequenceEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcSequenceEnum& getUnset() { static OdIfc2x_final::IfcSequenceEnum nullEnum = OdIfc2x_final::kIfcSequenceEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration indicates how the resource is consumed during the use. */ enum IfcResourceConsumptionEnum { /** CONSUMED.*/ kIfcResourceConsumptionEnum_CONSUMED, /** PARTIALLYCONSUMED.*/ kIfcResourceConsumptionEnum_PARTIALLYCONSUMED, /** NOTCONSUMED.*/ kIfcResourceConsumptionEnum_NOTCONSUMED, /** OCCUPIED.*/ kIfcResourceConsumptionEnum_OCCUPIED, /** PARTIALLYOCCUPIED.*/ kIfcResourceConsumptionEnum_PARTIALLYOCCUPIED, /** NOTOCCUPIED.*/ kIfcResourceConsumptionEnum_NOTOCCUPIED, /** USERDEFINED.*/ kIfcResourceConsumptionEnum_USERDEFINED, /** NOTDEFINED.*/ kIfcResourceConsumptionEnum_NOTDEFINED, /** The value is unset.*/ kIfcResourceConsumptionEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcResourceConsumptionEnum& getUnset() { static OdIfc2x_final::IfcResourceConsumptionEnum nullEnum = OdIfc2x_final::kIfcResourceConsumptionEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the applicable object categories (i.e. the subtypes at the 2nd level of the IFC inheritance tree) . Attached to an object, it indicates to which subtype of IfcObject the entity referencing it would otherwise comply with. */ enum IfcObjectTypeEnum { /** PRODUCT.*/ kIfcObjectTypeEnum_PRODUCT, /** PROCESS.*/ kIfcObjectTypeEnum_PROCESS, /** CONTROL.*/ kIfcObjectTypeEnum_CONTROL, /** RESOURCE.*/ kIfcObjectTypeEnum_RESOURCE, /** ACTOR.*/ kIfcObjectTypeEnum_ACTOR, /** GROUP.*/ kIfcObjectTypeEnum_GROUP, /** PROJECT.*/ kIfcObjectTypeEnum_PROJECT, /** NOTDEFINED.*/ kIfcObjectTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcObjectTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcObjectTypeEnum& getUnset() { static OdIfc2x_final::IfcObjectTypeEnum nullEnum = OdIfc2x_final::kIfcObjectTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the different types of space boundaries in terms of either being inside the building or outside the building. */ enum IfcInternalOrExternalEnum { /** The space boundary faces a physical or virtual element where there is an internal space on the other side.*/ kIfcInternalOrExternalEnum_INTERNAL, /** The space boundary faces a physical or virtual element where there is an external space on the other side.*/ kIfcInternalOrExternalEnum_EXTERNAL, /** No information available.*/ kIfcInternalOrExternalEnum_NOTDEFINED, /** The value is unset.*/ kIfcInternalOrExternalEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcInternalOrExternalEnum& getUnset() { static OdIfc2x_final::IfcInternalOrExternalEnum nullEnum = OdIfc2x_final::kIfcInternalOrExternalEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the different types of space boundaries in terms of its physical manifestation. A space boundary can either be physically dividing or can be a virtual divider. */ enum IfcPhysicalOrVirtualEnum { /** The space boundary is provided physically (by a physical element).*/ kIfcPhysicalOrVirtualEnum_PHYSICAL, /** The space boundary is provided virtually (by a logical divider that has no physical manifestation).*/ kIfcPhysicalOrVirtualEnum_VIRTUAL, /** No information available.*/ kIfcPhysicalOrVirtualEnum_NOTDEFINED, /** The value is unset.*/ kIfcPhysicalOrVirtualEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcPhysicalOrVirtualEnum& getUnset() { static OdIfc2x_final::IfcPhysicalOrVirtualEnum nullEnum = OdIfc2x_final::kIfcPhysicalOrVirtualEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration indicates the composition of a spatial structure element or proxy. */ enum IfcElementCompositionEnum { /** A group or aggregation of similar elements.*/ kIfcElementCompositionEnum_COMPLEX, /** An (undivided) element itself.*/ kIfcElementCompositionEnum_ELEMENT, /** A subelement or part.*/ kIfcElementCompositionEnum_PARTIAL, /** The value is unset.*/ kIfcElementCompositionEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcElementCompositionEnum& getUnset() { static OdIfc2x_final::IfcElementCompositionEnum nullEnum = OdIfc2x_final::kIfcElementCompositionEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration is used to identify primary transport element types. */ enum IfcTransportElementTypeEnum { /** Elevator or lift being a transport device to move people or goods vertically.*/ kIfcTransportElementTypeEnum_ELEVATOR, /** Escalator being a transport device to move people. It consists of individual linked steps that move up and down on tracks while keeping the threads horizontal.*/ kIfcTransportElementTypeEnum_ESCALATOR, /** Moving walkway being a transport device to move people horizontally or on an incline. It is a slow conveyor belt that transports people.*/ kIfcTransportElementTypeEnum_MOVINGWALKWAY, /** User-defined type.*/ kIfcTransportElementTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcTransportElementTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcTransportElementTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcTransportElementTypeEnum& getUnset() { static OdIfc2x_final::IfcTransportElementTypeEnum nullEnum = OdIfc2x_final::kIfcTransportElementTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the different ways how path based elements (such as layered IfcWall elements) can connect. */ enum IfcConnectionTypeEnum { /** Connection along the path of the connected element.*/ kIfcConnectionTypeEnum_ATPATH, /** Connection at the start of the connected element.*/ kIfcConnectionTypeEnum_ATSTART, /** Connection at the end of the connected element.*/ kIfcConnectionTypeEnum_ATEND, /** No description available.*/ kIfcConnectionTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcConnectionTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcConnectionTypeEnum& getUnset() { static OdIfc2x_final::IfcConnectionTypeEnum nullEnum = OdIfc2x_final::kIfcConnectionTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the range of different types of covering that can further specify an IfcCovering or an IfcCoveringType. */ enum IfcCoveringTypeEnum { /** The covering is used to represent a ceiling.*/ kIfcCoveringTypeEnum_CEILING, /** The covering is used to represent a flooring.*/ kIfcCoveringTypeEnum_FLOORING, /** The covering is used to represent a cladding.*/ kIfcCoveringTypeEnum_CLADDING, /** The covering is used to represent a roof covering.*/ kIfcCoveringTypeEnum_ROOFING, /** User defined type of covering.*/ kIfcCoveringTypeEnum_USERDEFINED, /** Undefined type of covering.*/ kIfcCoveringTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcCoveringTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcCoveringTypeEnum& getUnset() { static OdIfc2x_final::IfcCoveringTypeEnum nullEnum = OdIfc2x_final::kIfcCoveringTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the available predefined types of slabs that can further specify an IfcSlab or IfcSlabType. */ enum IfcSlabTypeEnum { /** The slab is used to represent a floor slab or a bridge deck.*/ kIfcSlabTypeEnum_FLOOR, /** The slab is used to represent a roof slab (either flat or sloped).*/ kIfcSlabTypeEnum_ROOF, /** The slab is used to represent a landing within a stair or ramp.*/ kIfcSlabTypeEnum_LANDING, /** No description available.*/ kIfcSlabTypeEnum_USERDEFINED, /** No description available.*/ kIfcSlabTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcSlabTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcSlabTypeEnum& getUnset() { static OdIfc2x_final::IfcSlabTypeEnum nullEnum = OdIfc2x_final::kIfcSlabTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the basic configuration of the roof in terms of the different roof shapes. */ enum IfcRoofTypeEnum { /** A roof having no slope, or one with only a slight pitch so as to drain rainwater.*/ kIfcRoofTypeEnum_FLAT_ROOF, /** A roof having a single slope.*/ kIfcRoofTypeEnum_SHED_ROOF, /** A roof sloping downward in two parts from a central ridge, so as to form a gable at each end.*/ kIfcRoofTypeEnum_GABLE_ROOF, /** A roof having sloping ends and sides meeting at an inclined projecting angle.*/ kIfcRoofTypeEnum_HIP_ROOF, /** A roof having a hipped end truncating a gable.*/ kIfcRoofTypeEnum_HIPPED_GABLE_ROOF, /** A roof sloping downward in two parts from a central ridge, so as to form a gable at each end.*/ kIfcRoofTypeEnum_GAMBREL_ROOF, /** A roof having on each side a steeper lower part and a shallower upper part.*/ kIfcRoofTypeEnum_MANSARD_ROOF, /** A roof or ceiling having a semicylindrical form.*/ kIfcRoofTypeEnum_BARREL_ROOF, /** A gable roof in the form of a broad Gothic arch, with gently sloping convex surfaces.*/ kIfcRoofTypeEnum_RAINBOW_ROOF, /** A roof having two slopes, each descending inward from the eaves.*/ kIfcRoofTypeEnum_BUTTERFLY_ROOF, /** A pyramidal hip roof.*/ kIfcRoofTypeEnum_PAVILION_ROOF, /** A hemispherical hip roof.*/ kIfcRoofTypeEnum_DOME_ROOF, /** Free form roof.*/ kIfcRoofTypeEnum_FREEFORM, /** No specification given.*/ kIfcRoofTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcRoofTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcRoofTypeEnum& getUnset() { static OdIfc2x_final::IfcRoofTypeEnum nullEnum = OdIfc2x_final::kIfcRoofTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the basic configuration of the stair type in terms of the number of stair flights and the number of landings. The type also distinguished turns by windings or by landings. In addition the subdivision of the straight and changing direction stairs is included. The stair configurations are given for stairs without and with one, two or three landings. */ enum IfcStairTypeEnum { /** A stair extending from one level to another without turns or winders. The stair consists of one straight flight.*/ kIfcStairTypeEnum_STRAIGHT_RUN_STAIR, /** A straight stair consisting of two straight flights without turns but with one landing.*/ kIfcStairTypeEnum_TWO_STRAIGHT_RUN_STAIR, /** A stair consisting of one flight with a quarter winder, which is making a 90° turn. The direction of the turn is determined by the walking line.*/ kIfcStairTypeEnum_QUARTER_WINDING_STAIR, /** A stair making a 90° turn, consisting of two straight flights connected by a quarterspace landing. The direction of the turn is determined by the walking line.*/ kIfcStairTypeEnum_QUARTER_TURN_STAIR, /** A stair consisting of one flight with one half winder, which makes a 180° turn. The orientation of the turn is determined by the walking line.*/ kIfcStairTypeEnum_HALF_WINDING_STAIR, /** A stair making a 180° turn, consisting of two straight flights connected. The orientation of the turn is determined by the walking line.*/ kIfcStairTypeEnum_HALF_TURN_STAIR, /** A stair consisting of one flight with two quarter winders, which make a 90° turn. The stair makes a 180° turn. The direction of the turns is determined by the walking line.*/ kIfcStairTypeEnum_TWO_QUARTER_WINDING_STAIR, /** A stair making a 180° turn, consisting of three straight flights connected by two quarterspace landings. The direction of the turns is determined by the walking line.*/ kIfcStairTypeEnum_TWO_QUARTER_TURN_STAIR, /** A stair consisting of one flight with three quarter winders, which make a 90° turn. The stair makes a 270° turn. The direction of the turns is determined by the walking line.*/ kIfcStairTypeEnum_THREE_QUARTER_WINDING_STAIR, /** A stair making a 270° turn, consisting of four straight flights connected by three quarterspace landings. The direction of the turns is determined by the walking line.*/ kIfcStairTypeEnum_THREE_QUARTER_TURN_STAIR, /** A stair constructed with winders around a circular newel often without landings. Depending on outer boundary it can be either a circular, elliptical or rectangular spiral stair. The orientation of the winding stairs is determined by the walking line.*/ kIfcStairTypeEnum_SPIRAL_STAIR, /** A stair having one straight flight to a wide quarterspace landing, and two side flights from that landing into opposite directions. The stair is making a 90° turn. The direction of traffic is determined by the walking line.*/ kIfcStairTypeEnum_DOUBLE_RETURN_STAIR, /** A stair extending from one level to another without turns or winders. The stair is consisting of one curved flight.*/ kIfcStairTypeEnum_CURVED_RUN_STAIR, /** A curved stair consisting of two curved flights without turns but with one landing.*/ kIfcStairTypeEnum_TWO_CURVED_RUN_STAIR, /** Free form stair (user defined operation type).*/ kIfcStairTypeEnum_USERDEFINED, /** No description available.*/ kIfcStairTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcStairTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcStairTypeEnum& getUnset() { static OdIfc2x_final::IfcStairTypeEnum nullEnum = OdIfc2x_final::kIfcStairTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the basic configuration of the ramp type in terms of the number and shape of ramp flights. The type also distinguished turns by landings. In addition the subdivision of the straight and changing direction ramps is included. The ramp configurations are given for ramps without and with one and two landings. */ enum IfcRampTypeEnum { /** A ramp - which is a sloping floor, walk, or roadway - connecting two levels. The straight ramp consists of one straight flight without turns or winders.*/ kIfcRampTypeEnum_STRAIGHT_RUN_RAMP, /** A straight ramp consisting of two straight flights without turns but with one landing.*/ kIfcRampTypeEnum_TWO_STRAIGHT_RUN_RAMP, /** A ramp making a 90° turn, consisting of two straight flights connected by a quarterspace landing. The direction of the turn is determined by the walking line.*/ kIfcRampTypeEnum_QUARTER_TURN_RAMP, /** A ramp making a 180° turn, consisting of three straight flights connected by two quarterspace landings. The direction of the turn is determined by the walking line.*/ kIfcRampTypeEnum_TWO_QUARTER_TURN_RAMP, /** A ramp making a 180° turn, consisting of two straight flights connected by a halfspace landing. The orientation of the turn is determined by the walking line.*/ kIfcRampTypeEnum_HALF_TURN_RAMP, /** A ramp constructed around a circular or elliptical well without newels and landings.*/ kIfcRampTypeEnum_SPIRAL_RAMP, /** Free form ramp (user defined operation type).*/ kIfcRampTypeEnum_USERDEFINED, /** No description available.*/ kIfcRampTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcRampTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcRampTypeEnum& getUnset() { static OdIfc2x_final::IfcRampTypeEnum nullEnum = OdIfc2x_final::kIfcRampTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the basic ways to describe how doors operate. */ enum IfcDoorStyleOperationEnum { /** Door with one panel that opens (swings) to the left. The hinges are on the left side as viewed in the direction of the positive y-axis. */ kIfcDoorStyleOperationEnum_SINGLE_SWING_LEFT, /** Door with one panel that swings in both directions and to the right in the main traffic direction. Also called double acting door. */ kIfcDoorStyleOperationEnum_SINGLE_SWING_RIGHT, /** Door with two panels, one swings in both directions and to the right in the main traffic direction the other swings also in both directions and to the left in the main traffic direction. */ kIfcDoorStyleOperationEnum_DOUBLE_DOOR_SINGLE_SWING, /** Door with two panels that both open to the left, one panel swings in one direction and the other panel swings in the opposite direction. */ kIfcDoorStyleOperationEnum_DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT, /** Door with two panels that both open to the right, one panel swings in one direction and the other panel swings in the opposite direction. */ kIfcDoorStyleOperationEnum_DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT, /** */ kIfcDoorStyleOperationEnum_DOUBLE_SWING_LEFT, /** */ kIfcDoorStyleOperationEnum_DOUBLE_SWING_RIGHT, /** */ kIfcDoorStyleOperationEnum_DOUBLE_DOOR_DOUBLE_SWING, /** Door with one panel that is sliding to the left. */ kIfcDoorStyleOperationEnum_SLIDING_TO_LEFT, /** Door with one panel that is sliding to the right. */ kIfcDoorStyleOperationEnum_SLIDING_TO_RIGHT, /** Door with two panels, one is sliding to the left the other is sliding to the right. */ kIfcDoorStyleOperationEnum_DOUBLE_DOOR_SLIDING, /** Door with one panel that is folding to the left. */ kIfcDoorStyleOperationEnum_FOLDING_TO_LEFT, /** Door with one panel that is folding to the right. */ kIfcDoorStyleOperationEnum_FOLDING_TO_RIGHT, /** Door with two panels, one is folding to the left the other is folding to the right. */ kIfcDoorStyleOperationEnum_DOUBLE_DOOR_FOLDING, /** An entrance door consisting of four leaves set in a form of a cross and revolving around a central vertical axis (the four panels are described by a single IfcDoor panel property). */ kIfcDoorStyleOperationEnum_REVOLVING, /** Door that opens by rolling up. */ kIfcDoorStyleOperationEnum_ROLLINGUP, /** User-defined operation type */ kIfcDoorStyleOperationEnum_USERDEFINED, /** A door with a not defined operation type is considered as a door with a lining, but no panels. It is thereby always open.*/ kIfcDoorStyleOperationEnum_NOTDEFINED, /** The value is unset.*/ kIfcDoorStyleOperationEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcDoorStyleOperationEnum& getUnset() { static OdIfc2x_final::IfcDoorStyleOperationEnum nullEnum = OdIfc2x_final::kIfcDoorStyleOperationEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the basic types of construction of doors. The construction type relates to the main material (or material combination) used for making the door. */ enum IfcDoorStyleConstructionEnum { /** Aluminum*/ kIfcDoorStyleConstructionEnum_ALUMINIUM, /** High grade steel*/ kIfcDoorStyleConstructionEnum_HIGH_GRADE_STEEL, /** Steel*/ kIfcDoorStyleConstructionEnum_STEEL, /** Wood*/ kIfcDoorStyleConstructionEnum_WOOD, /** Aluminum wood*/ kIfcDoorStyleConstructionEnum_ALUMINIUM_WOOD, /** Aluminum plastic*/ kIfcDoorStyleConstructionEnum_ALUMINIUM_PLASTIC, /** Plastic*/ kIfcDoorStyleConstructionEnum_PLASTIC, /** User-defined*/ kIfcDoorStyleConstructionEnum_USERDEFINED, /** Not defined*/ kIfcDoorStyleConstructionEnum_NOTDEFINED, /** The value is unset.*/ kIfcDoorStyleConstructionEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcDoorStyleConstructionEnum& getUnset() { static OdIfc2x_final::IfcDoorStyleConstructionEnum nullEnum = OdIfc2x_final::kIfcDoorStyleConstructionEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the basic types of construction of windows. The construction type relates to the main material (or material combination) used for making the window. */ enum IfcWindowStyleConstructionEnum { /** Aluminum*/ kIfcWindowStyleConstructionEnum_ALUMINIUM, /** High Grade steel*/ kIfcWindowStyleConstructionEnum_HIGH_GRADE_STEEL, /** Steel*/ kIfcWindowStyleConstructionEnum_STEEL, /** Wood*/ kIfcWindowStyleConstructionEnum_WOOD, /** Aluminum and wood*/ kIfcWindowStyleConstructionEnum_ALUMINIUM_WOOD, /** Plastic*/ kIfcWindowStyleConstructionEnum_PLASTIC, /** Other construction*/ kIfcWindowStyleConstructionEnum_OTHER_CONSTRUCTION, /** Undefined*/ kIfcWindowStyleConstructionEnum_NOTDEFINED, /** The value is unset.*/ kIfcWindowStyleConstructionEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcWindowStyleConstructionEnum& getUnset() { static OdIfc2x_final::IfcWindowStyleConstructionEnum nullEnum = OdIfc2x_final::kIfcWindowStyleConstructionEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the basic configuration of the window type in terms of the number of window panels and the subdivision of the total window. The window configurations are given for windows with one, two or three panels (including fixed panels). */ enum IfcWindowStyleOperationEnum { /** Window with one panel.*/ kIfcWindowStyleOperationEnum_SINGLE_PANEL, /** Window with two panels. The configuration of the panels is vertically.*/ kIfcWindowStyleOperationEnum_DOUBLE_PANEL_VERTICAL, /** Window with two panels. The configuration of the panels is horizontally.*/ kIfcWindowStyleOperationEnum_DOUBLE_PANEL_HORIZONTAL, /** Window with three panels. The configuration of the panels is vertically.*/ kIfcWindowStyleOperationEnum_TRIPLE_PANEL_VERTICAL, /** Window with three panels. The configuration of two panels is vertically and the third one is horizontally at the bottom.*/ kIfcWindowStyleOperationEnum_TRIPLE_PANEL_BOTTOM, /** Window with three panels. The configuration of two panels is vertically and the third one is horizontally at the top.*/ kIfcWindowStyleOperationEnum_TRIPLE_PANEL_TOP, /** Window with three panels. The configuration of two panels is horizontally and the third one is vertically at the left hand side.*/ kIfcWindowStyleOperationEnum_TRIPLE_PANEL_LEFT, /** Window with three panels. The configuration of two panels is horizontally and the third one is vertically at the right hand side.*/ kIfcWindowStyleOperationEnum_TRIPLE_PANEL_RIGHT, /** Window with three panels. The configuration of the panels is horizontally.*/ kIfcWindowStyleOperationEnum_TRIPLE_PANEL_HORIZONTAL, /** User-defined operation type.*/ kIfcWindowStyleOperationEnum_USERDEFINED, /** NOTDEFINED*/ kIfcWindowStyleOperationEnum_NOTDEFINED, /** The value is unset.*/ kIfcWindowStyleOperationEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcWindowStyleOperationEnum& getUnset() { static OdIfc2x_final::IfcWindowStyleOperationEnum nullEnum = OdIfc2x_final::kIfcWindowStyleOperationEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the basic ways how individual door panels operate. */ enum IfcDoorPanelOperationEnum { /** Swinging. */ kIfcDoorPanelOperationEnum_SWINGING, /** Double acting. */ kIfcDoorPanelOperationEnum_DOUBLE_ACTING, /** Sliding. */ kIfcDoorPanelOperationEnum_SLIDING, /** Folding. */ kIfcDoorPanelOperationEnum_FOLDING, /** Revolving. */ kIfcDoorPanelOperationEnum_REVOLVING, /** Rolling up. */ kIfcDoorPanelOperationEnum_ROLLINGUP, /** User-defined.*/ kIfcDoorPanelOperationEnum_USERDEFINED, /** Not defined.*/ kIfcDoorPanelOperationEnum_NOTDEFINED, /** The value is unset.*/ kIfcDoorPanelOperationEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcDoorPanelOperationEnum& getUnset() { static OdIfc2x_final::IfcDoorPanelOperationEnum nullEnum = OdIfc2x_final::kIfcDoorPanelOperationEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the basic ways to describe the location of a door panel within a door lining. */ enum IfcDoorPanelPositionEnum { /** Left*/ kIfcDoorPanelPositionEnum_LEFT, /** Middle*/ kIfcDoorPanelPositionEnum_MIDDLE, /** Right*/ kIfcDoorPanelPositionEnum_RIGHT, /** Not defined.*/ kIfcDoorPanelPositionEnum_NOTDEFINED, /** The value is unset.*/ kIfcDoorPanelPositionEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcDoorPanelPositionEnum& getUnset() { static OdIfc2x_final::IfcDoorPanelPositionEnum nullEnum = OdIfc2x_final::kIfcDoorPanelPositionEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the basic ways to describe how window panels operate. */ enum IfcWindowPanelOperationEnum { /** Panel that opens to the right when viewed from the outside.*/ kIfcWindowPanelOperationEnum_SIDEHUNGRIGHTHAND, /** Panel that opens to the left when viewed from the outside.*/ kIfcWindowPanelOperationEnum_SIDEHUNGLEFTHAND, /** Panel that opens to the right and is bottom hung.*/ kIfcWindowPanelOperationEnum_TILTANDTURNRIGHTHAND, /** Panel that opens to the left and is bottom hung.*/ kIfcWindowPanelOperationEnum_TILTANDTURNLEFTHAND, /** Panel is top hung.*/ kIfcWindowPanelOperationEnum_TOPHUNG, /** Panel is bottom hung.*/ kIfcWindowPanelOperationEnum_BOTTOMHUNG, /** Panel is swinging horizontally (hinges are in the middle).*/ kIfcWindowPanelOperationEnum_PIVOTHORIZONTAL, /** Panel is swinging vertically (hinges are in the middle).*/ kIfcWindowPanelOperationEnum_PIVOTVERTICAL, /** Panel is sliding horizontally.*/ kIfcWindowPanelOperationEnum_SLIDINGHORIZONTAL, /** Panel is sliding vertically.*/ kIfcWindowPanelOperationEnum_SLIDINGVERTICAL, /** Panel is removable.*/ kIfcWindowPanelOperationEnum_REMOVABLECASEMENT, /** Panel is fixed.*/ kIfcWindowPanelOperationEnum_FIXEDCASEMENT, /** Other.*/ kIfcWindowPanelOperationEnum_OTHEROPERATION, /** Undefined.*/ kIfcWindowPanelOperationEnum_NOTDEFINED, /** The value is unset.*/ kIfcWindowPanelOperationEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcWindowPanelOperationEnum& getUnset() { static OdIfc2x_final::IfcWindowPanelOperationEnum nullEnum = OdIfc2x_final::kIfcWindowPanelOperationEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the basic configuration of the window type in terms of the location of window panels. The window configurations are given for windows with one, two or three panels (including fixed panels). It corresponds to the OperationType of the IfcWindowType definition, which references the IfcWindowPanelProperties. */ enum IfcWindowPanelPositionEnum { /** Left*/ kIfcWindowPanelPositionEnum_LEFT, /** Middle*/ kIfcWindowPanelPositionEnum_MIDDLE, /** Right*/ kIfcWindowPanelPositionEnum_RIGHT, /** Bottom*/ kIfcWindowPanelPositionEnum_BOTTOM, /** Top*/ kIfcWindowPanelPositionEnum_TOP, /** Undefined.*/ kIfcWindowPanelPositionEnum_NOTDEFINED, /** The value is unset.*/ kIfcWindowPanelPositionEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcWindowPanelPositionEnum& getUnset() { static OdIfc2x_final::IfcWindowPanelPositionEnum nullEnum = OdIfc2x_final::kIfcWindowPanelPositionEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Enumeration defining the result or current status of the approval process. */ enum IfcApprovalStatusEnum { /** APPROVED*/ kIfcApprovalStatusEnum_APPROVED, /** PROCESSED*/ kIfcApprovalStatusEnum_PROCESSED, /** ONHOLD*/ kIfcApprovalStatusEnum_ONHOLD, /** SUBMITTED*/ kIfcApprovalStatusEnum_SUBMITTED, /** USERDEFINED*/ kIfcApprovalStatusEnum_USERDEFINED, /** NOTDEFINED*/ kIfcApprovalStatusEnum_NOTDEFINED, /** The value is unset.*/ kIfcApprovalStatusEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcApprovalStatusEnum& getUnset() { static OdIfc2x_final::IfcApprovalStatusEnum nullEnum = OdIfc2x_final::kIfcApprovalStatusEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details IfcBenchmarkEnum is an enumeration used to identify the logical comparators that can be applied in conjunction with constraint values. */ enum IfcBenchmarkEnum { /** Identifies that a value must be greater than that set by the constraint.*/ kIfcBenchmarkEnum_GREATERTHAN, /** Identifies that a value must be either greater than or equal to that set by the constraint.*/ kIfcBenchmarkEnum_GREATERTHANOREQUALTO, /** Identifies that a value must be less than that set by the constraint.*/ kIfcBenchmarkEnum_LESSTHAN, /** Identifies that a value must be either less than or equal to that set by the constraint.*/ kIfcBenchmarkEnum_LESSTHANOREQUALTO, /** Identifies that a value must be equal to that set by the constraint.*/ kIfcBenchmarkEnum_EQUALTO, /** Identifies that a value must be not equal to that set by the constraint.*/ kIfcBenchmarkEnum_NOTEQUALTO, kIfcBenchmarkEnum_TARGETWITHTOLERANCE, kIfcBenchmarkEnum_RANGE, kIfcBenchmarkEnum_USERDEFINED, /** Not defined.*/ kIfcBenchmarkEnum_NOTDEFINED, /** The value is unset.*/ kIfcBenchmarkEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcBenchmarkEnum& getUnset() { static OdIfc2x_final::IfcBenchmarkEnum nullEnum = OdIfc2x_final::kIfcBenchmarkEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Description. */ enum IfcMetricDataEnum { /** SCALAR.*/ kIfcMetricDataEnum_SCALAR, /** VECTOR.*/ kIfcMetricDataEnum_VECTOR, /** TIMESERIES.*/ kIfcMetricDataEnum_TIMESERIES, /** TABLE.*/ kIfcMetricDataEnum_TABLE, /** GRAPH.*/ kIfcMetricDataEnum_GRAPH, /** DISTRIBUTION.*/ kIfcMetricDataEnum_DISTRIBUTION, /** USERDEFINED.*/ kIfcMetricDataEnum_USERDEFINED, /** NOTDEFINED.*/ kIfcMetricDataEnum_NOTDEFINED, /** The value is unset.*/ kIfcMetricDataEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcMetricDataEnum& getUnset() { static OdIfc2x_final::IfcMetricDataEnum nullEnum = OdIfc2x_final::kIfcMetricDataEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details IfcObjectiveEnum is an enumeration used to determine the objective for which purpose the constraint needs to be satisfied. */ enum IfcObjectiveEnum { /** A constraint whose objective is to ensure satisfaction of a code compliance provision.*/ kIfcObjectiveEnum_CODECOMPLIANCE, /** A constraint whose objective is to ensure satisfaction of a design intent provision.*/ kIfcObjectiveEnum_DESIGNINTENT, /** No description available.*/ kIfcObjectiveEnum_USERDEFINED, /** No description available.*/ kIfcObjectiveEnum_NOTDEFINED, /** The value is unset.*/ kIfcObjectiveEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcObjectiveEnum& getUnset() { static OdIfc2x_final::IfcObjectiveEnum nullEnum = OdIfc2x_final::kIfcObjectiveEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details IfcConstraintEnum is an enumeration used to qualify a constraint. */ enum IfcConstraintEnum { /** Qualifies a constraint such that it must be followed rigidly within or at the values set.*/ kIfcConstraintEnum_HARD, /** Qualifies a constraint such that it should be followed within or at the values set.*/ kIfcConstraintEnum_SOFT, /** Qualifies a constraint such that it is advised that it is followed within or at the values set.*/ kIfcConstraintEnum_ADVISORY, /** A user-defined grade indicated by a separate attribute at the referencing entity.*/ kIfcConstraintEnum_USERDEFINED, /** Grade has not been specified.*/ kIfcConstraintEnum_NOTDEFINED, /** The value is unset.*/ kIfcConstraintEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcConstraintEnum& getUnset() { static OdIfc2x_final::IfcConstraintEnum nullEnum = OdIfc2x_final::kIfcConstraintEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Enumeration defining the logical operators for aggregation. */ enum IfcAggregatorEnum { /** LOGICALAND*/ kIfcAggregatorEnum_LOGICALAND, /** LOGICALOR*/ kIfcAggregatorEnum_LOGICALOR, /** LOGICALXOR*/ kIfcAggregatorEnum_LOGICALXOR, /** LOGICALNOT*/ kIfcAggregatorEnum_LOGICALNOT, /** The value is unset.*/ kIfcAggregatorEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcAggregatorEnum& getUnset() { static OdIfc2x_final::IfcAggregatorEnum nullEnum = OdIfc2x_final::kIfcAggregatorEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Enumeration defining the intent of the constraint usage with regard to its related IfcConstraint and IfcObjects. */ enum IfcConstraintIntentEnum { /** RATIONALE*/ kIfcConstraintIntentEnum_RATIONALE, /** EXPECTEDPERFORMANCE*/ kIfcConstraintIntentEnum_EXPECTEDPERFORMANCE, /** USERDEFINED*/ kIfcConstraintIntentEnum_USERDEFINED, /** NOTDEFINED*/ kIfcConstraintIntentEnum_NOTDEFINED, /** The value is unset.*/ kIfcConstraintIntentEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcConstraintIntentEnum& getUnset() { static OdIfc2x_final::IfcConstraintIntentEnum nullEnum = OdIfc2x_final::kIfcConstraintIntentEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details The manner in which cost modifiers are applied to a cost. */ enum IfcCostModifierBasisEnum { /** RUNNING*/ kIfcCostModifierBasisEnum_RUNNING, /** STATIC*/ kIfcCostModifierBasisEnum_STATIC, /** The value is unset.*/ kIfcCostModifierBasisEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcCostModifierBasisEnum& getUnset() { static OdIfc2x_final::IfcCostModifierBasisEnum nullEnum = OdIfc2x_final::kIfcCostModifierBasisEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details A mathematical operator which determines how the cost modifier is to be applied to the cost to vary its value. Cost operators are specified as being by value or by percent. If the operator is by value (add, subtract or multiply), this means that cost modifiers are applied directly according to the value attribute of the modifier. That is, for a selection of 'AddValue' with a value attribute of 20 on a cost of $120, the modified value would be determined by $120 + $20 = $140. If the operator is by percent(add, subtract or multiply), this means that cost modifiers are applied by transforming the value attribute from a percentage to an actual value. That is, for a selection of 'AddPercent' with a value attribute of 20 on a cost of $120, the modified value would be determined by $120 + $(120 * 20/100) = $144. */ enum IfcCostOperatorEnum { /** ADDVALUE*/ kIfcCostOperatorEnum_ADDVALUE, /** SUBTRACTVALUE*/ kIfcCostOperatorEnum_SUBTRACTVALUE, /** MULTIPLYVALUE*/ kIfcCostOperatorEnum_MULTIPLYVALUE, /** The value is unset.*/ kIfcCostOperatorEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcCostOperatorEnum& getUnset() { static OdIfc2x_final::IfcCostOperatorEnum nullEnum = OdIfc2x_final::kIfcCostOperatorEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details The manner in which cost value is rounded up. */ enum IfcQuantityRoundOffBasisEnum { /** ROUNDTOCLOSEST*/ kIfcQuantityRoundOffBasisEnum_ROUNDTOCLOSEST, /** ROUNDTUP*/ kIfcQuantityRoundOffBasisEnum_ROUNDTUP, /** ROUNDTDOWN*/ kIfcQuantityRoundOffBasisEnum_ROUNDTDOWN, /** NONE*/ kIfcQuantityRoundOffBasisEnum_NONE, /** The value is unset.*/ kIfcQuantityRoundOffBasisEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcQuantityRoundOffBasisEnum& getUnset() { static OdIfc2x_final::IfcQuantityRoundOffBasisEnum nullEnum = OdIfc2x_final::kIfcQuantityRoundOffBasisEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Denotion of whether negative, positive or both sides of a surface are being referred to. */ enum IfcSurfaceSideEnum { /** POSITIVE*/ kIfcSurfaceSideEnum_POSITIVE, /** NEGATIVE*/ kIfcSurfaceSideEnum_NEGATIVE, /** BOTH*/ kIfcSurfaceSideEnum_BOTH, /** The value is unset.*/ kIfcSurfaceSideEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcSurfaceSideEnum& getUnset() { static OdIfc2x_final::IfcSurfaceSideEnum nullEnum = OdIfc2x_final::kIfcSurfaceSideEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Indicates the range of values that can be selected from the enumeration. */ enum IfcTaskStatusEnum { /** COMPLETED*/ kIfcTaskStatusEnum_COMPLETED, /** NOTYETSTARTED*/ kIfcTaskStatusEnum_NOTYETSTARTED, /** STARTED*/ kIfcTaskStatusEnum_STARTED, /** USERDEFINED*/ kIfcTaskStatusEnum_USERDEFINED, /** NOTDEFINED*/ kIfcTaskStatusEnum_NOTDEFINED, /** The value is unset.*/ kIfcTaskStatusEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcTaskStatusEnum& getUnset() { static OdIfc2x_final::IfcTaskStatusEnum nullEnum = OdIfc2x_final::kIfcTaskStatusEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Indicates the range of values that can be selected from the enumeration. */ enum IfcTaskMilestoneEnum { /** CONTRACTMILESTONE*/ kIfcTaskMilestoneEnum_CONTRACTMILESTONE, /** CUSTOMERMILESTONE*/ kIfcTaskMilestoneEnum_CUSTOMERMILESTONE, /** FINANCIALMILESTONE*/ kIfcTaskMilestoneEnum_FINANCIALMILESTONE, /** FINISHMILESTONE*/ kIfcTaskMilestoneEnum_FINISHMILESTONE, /** MANAGEMENTMILESTONE*/ kIfcTaskMilestoneEnum_MANAGEMENTMILESTONE, /** SCHEDULEDMILESTONE*/ kIfcTaskMilestoneEnum_SCHEDULEDMILESTONE, /** STARTMILESTONE*/ kIfcTaskMilestoneEnum_STARTMILESTONE, /** SUPPLYMILESTONE*/ kIfcTaskMilestoneEnum_SUPPLYMILESTONE, /** USERDEFINED*/ kIfcTaskMilestoneEnum_USERDEFINED, /** NOTDEFINED*/ kIfcTaskMilestoneEnum_NOTDEFINED, /** The value is unset.*/ kIfcTaskMilestoneEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcTaskMilestoneEnum& getUnset() { static OdIfc2x_final::IfcTaskMilestoneEnum nullEnum = OdIfc2x_final::kIfcTaskMilestoneEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details An IfcWorkControlTypeEnum is an enumeration data type that specifies the types of work control from which the relevant control can be selected. */ enum IfcWorkControlTypeEnum { /** A control in which actual items undertaken are indicated.*/ kIfcWorkControlTypeEnum_ACTUAL, /** A control that is a baseline from which changes that are made later can be recognized.*/ kIfcWorkControlTypeEnum_BASELINE, /** A control showing planned items.*/ kIfcWorkControlTypeEnum_PLANNED, /** The value is unset.*/ kIfcWorkControlTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcWorkControlTypeEnum& getUnset() { static OdIfc2x_final::IfcWorkControlTypeEnum nullEnum = OdIfc2x_final::kIfcWorkControlTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Indicates the range of values that can be selected from the enumeration. */ enum IfcMultiplierOrDivider { /** Multiplier*/ kIfcMultiplierOrDivider_MULTIPLIER, /** Divider.*/ kIfcMultiplierOrDivider_DIVIDER, /** The value is unset.*/ kIfcMultiplierOrDivider_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcMultiplierOrDivider& getUnset() { static OdIfc2x_final::IfcMultiplierOrDivider nullEnum = OdIfc2x_final::kIfcMultiplierOrDivider_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the flow direction at a distribution port. */ enum IfcFlowDirectionEnum { /** A flow source, where a substance flows out of the connection.*/ kIfcFlowDirectionEnum_SOURCE, /** A flow sink, where a substance flows into the connection.*/ kIfcFlowDirectionEnum_SINK, /** Both a source and sink, where a substance flows both into and out of the connection simultaneously.*/ kIfcFlowDirectionEnum_SOURCEANDSINK, /** User-defined flow direction.*/ kIfcFlowDirectionEnum_USERDEFINED, /** Undefined flow direction.*/ kIfcFlowDirectionEnum_NOTDEFINED, /** The value is unset.*/ kIfcFlowDirectionEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcFlowDirectionEnum& getUnset() { static OdIfc2x_final::IfcFlowDirectionEnum nullEnum = OdIfc2x_final::kIfcFlowDirectionEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Types of typical port connections specifically for duct and pipe connections. */ enum IfcPortConnectionTypeEnum { /** Angle.*/ kIfcPortConnectionTypeEnum_ANGLE, /** Beaded Sleeve.*/ kIfcPortConnectionTypeEnum_BEADEDSLEEVE, /** Brazed.*/ kIfcPortConnectionTypeEnum_BRAZED, /** Compression.*/ kIfcPortConnectionTypeEnum_COMPRESSION, /** Crimp.*/ kIfcPortConnectionTypeEnum_CRIMP, /** Drawband.*/ kIfcPortConnectionTypeEnum_DRAWBAND, /** Drive slip.*/ kIfcPortConnectionTypeEnum_DRIVESLIP, /** Flanged.*/ kIfcPortConnectionTypeEnum_FLANGED, /** Grooved.*/ kIfcPortConnectionTypeEnum_GROOVED, /** Outside Sleeve.*/ kIfcPortConnectionTypeEnum_OUTSIDESLEEVE, /** Slipon.*/ kIfcPortConnectionTypeEnum_SLIPON, /** Soldered.*/ kIfcPortConnectionTypeEnum_SOLDERED, /** S-Slip.*/ kIfcPortConnectionTypeEnum_SSLIP, /** Standing seam.*/ kIfcPortConnectionTypeEnum_STANDINGSEAM, /** Swedge.*/ kIfcPortConnectionTypeEnum_SWEDGE, /** Threaded.*/ kIfcPortConnectionTypeEnum_THREADED, /** Welded.*/ kIfcPortConnectionTypeEnum_WELDED, /** User-defined port connection type.*/ kIfcPortConnectionTypeEnum_USERDEFINED, /** Undefined port connection type.*/ kIfcPortConnectionTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcPortConnectionTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcPortConnectionTypeEnum& getUnset() { static OdIfc2x_final::IfcPortConnectionTypeEnum nullEnum = OdIfc2x_final::kIfcPortConnectionTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the different types of discrete elements an IfcDiscreteElement object can fulfill. */ enum IfcDiscreteElementTypeEnum { /** Materials with low heat conductance.*/ kIfcDiscreteElementTypeEnum_INSULATION, /** User-defined discrete element.*/ kIfcDiscreteElementTypeEnum_USERDEFINED, /** Not defined discrete element.*/ kIfcDiscreteElementTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcDiscreteElementTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcDiscreteElementTypeEnum& getUnset() { static OdIfc2x_final::IfcDiscreteElementTypeEnum nullEnum = OdIfc2x_final::kIfcDiscreteElementTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the different types of fittings an IfcFlowFitting object can fulfill. */ enum IfcFlowFittingTypeEnum { /** Duct fitting.*/ kIfcFlowFittingTypeEnum_DUCTFITTING, /** Pipe fitting.*/ kIfcFlowFittingTypeEnum_PIPEFITTING, /** User-defined fitting.*/ kIfcFlowFittingTypeEnum_USERDEFINED, /** Undefined fitting.*/ kIfcFlowFittingTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcFlowFittingTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcFlowFittingTypeEnum& getUnset() { static OdIfc2x_final::IfcFlowFittingTypeEnum nullEnum = OdIfc2x_final::kIfcFlowFittingTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration is used to identify the primary purpose of a fitting. This is a very basic categorization mechanism to generically identify the fitting type. Subcategories of fittings are not enumerated. */ enum IfcPrimaryFittingEnum { /** Entry fitting, typically unconnected at one port and connected to a flow distribution system at the other (e.g., an outside air duct system intake opening).*/ kIfcPrimaryFittingEnum_ENTRY, /** Exit fitting, typically unconnected at one port and connected to a flow distribution system at the other (e.g., an exhaust air discharge opening).*/ kIfcPrimaryFittingEnum_EXIT, /** A fitting with typically two ports used to change the direction of flow between connected elements.*/ kIfcPrimaryFittingEnum_ELBOW, /** A fitting with typically two ports having different shapes or sizes. Can also be used to change the direction of flow between connected elements.*/ kIfcPrimaryFittingEnum_TRANSITION, /** A fitting with typically more than two ports used to redistribute flow among the ports and/or to change the direction of flow between connected elements (e.g, tee, cross, wye, etc.).*/ kIfcPrimaryFittingEnum_JUNCTION, /** A fitting with typically two ports used to obstruct or restrict flow between the connected elements (e.g., screen, perforated plate, etc.).*/ kIfcPrimaryFittingEnum_OBSTRUCTION, /** Other type of primary fitting type not defined above.*/ kIfcPrimaryFittingEnum_OTHER, /** User-defined fitting.*/ kIfcPrimaryFittingEnum_USERDEFINED, /** Undefined fitting.*/ kIfcPrimaryFittingEnum_NOTDEFINED, /** The value is unset.*/ kIfcPrimaryFittingEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcPrimaryFittingEnum& getUnset() { static OdIfc2x_final::IfcPrimaryFittingEnum nullEnum = OdIfc2x_final::kIfcPrimaryFittingEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the different types of flow segments an IfcFlowSegment object can fulfill. */ enum IfcFlowSegmentTypeEnum { /** Duct segment.*/ kIfcFlowSegmentTypeEnum_DUCTSEGMENT, /** Puct segment.*/ kIfcFlowSegmentTypeEnum_PIPESEGMENT, /** Gutter segment.*/ kIfcFlowSegmentTypeEnum_GUTTERSEGMENT, /** User-defined segment.*/ kIfcFlowSegmentTypeEnum_USERDEFINED, /** Undefined segment.*/ kIfcFlowSegmentTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcFlowSegmentTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcFlowSegmentTypeEnum& getUnset() { static OdIfc2x_final::IfcFlowSegmentTypeEnum nullEnum = OdIfc2x_final::kIfcFlowSegmentTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Enumeration defining the functional type of AirFlow. */ enum IfcAirFlowTypeEnum { /** Supply air.*/ kIfcAirFlowTypeEnum_SUPPLYAIR, kIfcAirFlowTypeEnum_RETURNAIR, /** Exhaust air.*/ kIfcAirFlowTypeEnum_EXHAUSTAIR, /** Other type of AirFlow not defined above.*/ kIfcAirFlowTypeEnum_OTHER, /** Unknown AirFlow type.*/ kIfcAirFlowTypeEnum_NOTKNOWN, kIfcAirFlowTypeEnum_UNSET, /** The value is unset.*/ kIfcAirFlowTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcAirFlowTypeEnum& getUnset() { static OdIfc2x_final::IfcAirFlowTypeEnum nullEnum = OdIfc2x_final::kIfcAirFlowTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Enumeration that identifies the type of finish for the air terminal. */ enum IfcAirTerminalFinishTypeEnum { /** The AirTerminal has an Annodized finish.*/ kIfcAirTerminalFinishTypeEnum_ANNODIZED, /** The AirTerminal has a Painted finish.*/ kIfcAirTerminalFinishTypeEnum_PAINTED, /** No finish is applied to the AirTerminal.*/ kIfcAirTerminalFinishTypeEnum_NONE, /** Other type of finish not defined above.*/ kIfcAirTerminalFinishTypeEnum_OTHER, /** Unknown finish type.*/ kIfcAirTerminalFinishTypeEnum_NOTKNOWN, kIfcAirTerminalFinishTypeEnum_UNSET, /** The value is unset.*/ kIfcAirTerminalFinishTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcAirTerminalFinishTypeEnum& getUnset() { static OdIfc2x_final::IfcAirTerminalFinishTypeEnum nullEnum = OdIfc2x_final::kIfcAirTerminalFinishTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Enumeration that identifies the way the AirTerminal is mounted. */ enum IfcAirTerminalMountingTypeEnum { /** The AirTerminal is mounted to the surface of something (e.g., wall, duct, etc.).*/ kIfcAirTerminalMountingTypeEnum_SURFACE, /** The AirTerminal is mounted flat and flush with a surface.*/ kIfcAirTerminalMountingTypeEnum_FLATFLUSH, /** The AirTerminal is mounted in a lay-in type ceiling (e.g., a dropped ceiling grid).*/ kIfcAirTerminalMountingTypeEnum_LAYIN, /** Other type of mounting not defined above.*/ kIfcAirTerminalMountingTypeEnum_OTHER, /** Unknown mounting type.*/ kIfcAirTerminalMountingTypeEnum_NOTKNOWN, kIfcAirTerminalMountingTypeEnum_UNSET, /** The value is unset.*/ kIfcAirTerminalMountingTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcAirTerminalMountingTypeEnum& getUnset() { static OdIfc2x_final::IfcAirTerminalMountingTypeEnum nullEnum = OdIfc2x_final::kIfcAirTerminalMountingTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Enumeration that identifies the how the AirTerminal face is constructed. The face of the AirTerminal is that part where air is either collected or distributed to or from the space. */ enum IfcAirTerminalFaceTypeEnum { /** The AirTerminal face has a four-way pattern potentially allowing air to be directed in four different directions.*/ kIfcAirTerminalFaceTypeEnum_FOURWAYPATTERN, /** The AirTerminal face allows air to be directed in only one direction.*/ kIfcAirTerminalFaceTypeEnum_SINGLEDEFLECTION, /** The AirTerminal face allows air to be directed in two directions.*/ kIfcAirTerminalFaceTypeEnum_DOUBLEDEFLECTION, /** The AirTerminal face is sight-proof making it difficult to see into the AirTerminal.*/ kIfcAirTerminalFaceTypeEnum_SIGHTPROOF, /** The AirTerminal face has an egg-crate pattern.*/ kIfcAirTerminalFaceTypeEnum_EGGCRATE, /** The AirTerminal face has a perforated pattern.*/ kIfcAirTerminalFaceTypeEnum_PERFORATED, /** The AirTerminal face has a louvered pattern.*/ kIfcAirTerminalFaceTypeEnum_LOUVERED, /** Other type of face type not defined above.*/ kIfcAirTerminalFaceTypeEnum_OTHER, kIfcAirTerminalFaceTypeEnum_NOTKNOWN, kIfcAirTerminalFaceTypeEnum_UNSET, /** The value is unset.*/ kIfcAirTerminalFaceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcAirTerminalFaceTypeEnum& getUnset() { static OdIfc2x_final::IfcAirTerminalFaceTypeEnum nullEnum = OdIfc2x_final::kIfcAirTerminalFaceTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Enumeration that identifies the way the core of the AirTerminal is constructed. */ enum IfcAirTerminalCoreTypeEnum { /** The AirTerminal has a shutter-blade core.*/ kIfcAirTerminalCoreTypeEnum_SHUTTERBLADE, /** The AirTerminal has a curved-blade core.*/ kIfcAirTerminalCoreTypeEnum_CURVEDBLADE, /** The AirTerminal has a removable core.*/ kIfcAirTerminalCoreTypeEnum_REMOVABLE, /** The AirTerminal has a reversible core.*/ kIfcAirTerminalCoreTypeEnum_REVERSIBLE, /** The AirTerminal has no core.*/ kIfcAirTerminalCoreTypeEnum_NONE, /** Other type of core not defined above.*/ kIfcAirTerminalCoreTypeEnum_OTHER, /** Unknown core type.*/ kIfcAirTerminalCoreTypeEnum_NOTKNOWN, kIfcAirTerminalCoreTypeEnum_UNSET, /** The value is unset.*/ kIfcAirTerminalCoreTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcAirTerminalCoreTypeEnum& getUnset() { static OdIfc2x_final::IfcAirTerminalCoreTypeEnum nullEnum = OdIfc2x_final::kIfcAirTerminalCoreTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details The IfcSanitaryTerminalTypeEnum defines the range of different types of sanitary terminal that can be specified. */ enum IfcSanitaryTerminalTypeEnum { /** Faucet.*/ kIfcSanitaryTerminalTypeEnum_FAUCET, kIfcSanitaryTerminalTypeEnum_ROOFDRAIN, /** Installation or waste water appliance that emits a spray of water to wash the human body.*/ kIfcSanitaryTerminalTypeEnum_SHOWER, /** Waste water appliance for receiving, retaining or disposing of domestic, culinary, laboratory or industrial process liquids.*/ kIfcSanitaryTerminalTypeEnum_SINK, kIfcSanitaryTerminalTypeEnum_TOILET, /** Soil appliance that receives urine and directs it to a waste outlet.*/ kIfcSanitaryTerminalTypeEnum_URINAL, /** User-defined type.*/ kIfcSanitaryTerminalTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcSanitaryTerminalTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcSanitaryTerminalTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcSanitaryTerminalTypeEnum& getUnset() { static OdIfc2x_final::IfcSanitaryTerminalTypeEnum nullEnum = OdIfc2x_final::kIfcSanitaryTerminalTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Enumeration defining the functional type of HydronicHeater. */ enum IfcHydronicHeaterTypeEnum { /** Panel type Radiator.*/ kIfcHydronicHeaterTypeEnum_PANELRADIATOR, /** Column type Radiator.*/ kIfcHydronicHeaterTypeEnum_COLUMNRADIATOR, /** Tube type Radiator.*/ kIfcHydronicHeaterTypeEnum_TUBERADIATOR, /** Convector*/ kIfcHydronicHeaterTypeEnum_CONVECTOR, /** Baseboard heater.*/ kIfcHydronicHeaterTypeEnum_BASEBOARDHEATER, /** Fin-tube heater.*/ kIfcHydronicHeaterTypeEnum_FINTUBEHEATER, /** Other type of HydronicHeater not defined above.*/ kIfcHydronicHeaterTypeEnum_OTHER, /** Unknown HydronicHeater type.*/ kIfcHydronicHeaterTypeEnum_NOTKNOWN, kIfcHydronicHeaterTypeEnum_UNSET, /** The value is unset.*/ kIfcHydronicHeaterTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcHydronicHeaterTypeEnum& getUnset() { static OdIfc2x_final::IfcHydronicHeaterTypeEnum nullEnum = OdIfc2x_final::kIfcHydronicHeaterTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Enumeration defining the typical types of coils. */ enum IfcCoilTypeEnum { /** Precooling coil.*/ kIfcCoilTypeEnum_PRECOOLING, /** Cooling coil.*/ kIfcCoilTypeEnum_COOLING, /** Recooling coil.*/ kIfcCoilTypeEnum_RECOOLING, /** Preheating coil.*/ kIfcCoilTypeEnum_PREHEATING, /** Heating coil.*/ kIfcCoilTypeEnum_HEATING, /** Reheating coil.*/ kIfcCoilTypeEnum_REHEATING, kIfcCoilTypeEnum_OTHER, kIfcCoilTypeEnum_NOTKNOWN, kIfcCoilTypeEnum_UNSET, /** The value is unset.*/ kIfcCoilTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcCoilTypeEnum& getUnset() { static OdIfc2x_final::IfcCoilTypeEnum nullEnum = OdIfc2x_final::kIfcCoilTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Flow arrangement of the coil. */ enum IfcCoilFlowArrangementEnum { /** Counterflow coil arrangement.*/ kIfcCoilFlowArrangementEnum_COUNTERFLOW, /** Crossflow coil arrangement.*/ kIfcCoilFlowArrangementEnum_CROSSFLOW, /** Parallel flow coil arrangement.*/ kIfcCoilFlowArrangementEnum_PARALLELFLOW, /** Direct Expansion flow coil arrangement.*/ kIfcCoilFlowArrangementEnum_DIRECTEXPANSION, /** Other type of Coil flow arrangement not defined above.*/ kIfcCoilFlowArrangementEnum_OTHER, /** Unknown Coil flow arrangement.*/ kIfcCoilFlowArrangementEnum_NOTKNOWN, kIfcCoilFlowArrangementEnum_UNSET, /** The value is unset.*/ kIfcCoilFlowArrangementEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcCoilFlowArrangementEnum& getUnset() { static OdIfc2x_final::IfcCoilFlowArrangementEnum nullEnum = OdIfc2x_final::kIfcCoilFlowArrangementEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Enumeration defining the typical types of heat exchangers. */ enum IfcHeatExchangerTypeEnum { /** Plate heat exchanger.*/ kIfcHeatExchangerTypeEnum_PLATE, /** Shell and Tube heat exchanger.*/ kIfcHeatExchangerTypeEnum_SHELLANDTUBE, kIfcHeatExchangerTypeEnum_OTHER, /** Unknown heat exchanger type.*/ kIfcHeatExchangerTypeEnum_NOTKNOWN, kIfcHeatExchangerTypeEnum_UNSET, /** The value is unset.*/ kIfcHeatExchangerTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcHeatExchangerTypeEnum& getUnset() { static OdIfc2x_final::IfcHeatExchangerTypeEnum nullEnum = OdIfc2x_final::kIfcHeatExchangerTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Flow arrangement of the heat exchanger. */ enum IfcHeatExchangerArrangementEnum { /** Counterflow heat exchanger arrangement.*/ kIfcHeatExchangerArrangementEnum_COUNTERFLOW, /** Crossflow heat exchanger arrangement.*/ kIfcHeatExchangerArrangementEnum_CROSSFLOW, /** Parallel flow heat exchanger arrangement.*/ kIfcHeatExchangerArrangementEnum_PARALLELFLOW, /** Multipass flow heat exchanger arrangement.*/ kIfcHeatExchangerArrangementEnum_MULTIPASS, /** Other type of heat exchanger flow arrangement not defined above.*/ kIfcHeatExchangerArrangementEnum_OTHER, /** Unknown heat exchanger flow arrangement.*/ kIfcHeatExchangerArrangementEnum_NOTKNOWN, kIfcHeatExchangerArrangementEnum_UNSET, /** The value is unset.*/ kIfcHeatExchangerArrangementEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcHeatExchangerArrangementEnum& getUnset() { static OdIfc2x_final::IfcHeatExchangerArrangementEnum nullEnum = OdIfc2x_final::kIfcHeatExchangerArrangementEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Enumeration defining the typical types of cooling towers. */ enum IfcCoolingTowerTypeEnum { /** Open cooling tower.*/ kIfcCoolingTowerTypeEnum_OPENTOWER, /** Closed cooling tower.*/ kIfcCoolingTowerTypeEnum_CLOSEDTOWER, /** Wood fill cooling tower.*/ kIfcCoolingTowerTypeEnum_WOODFILL, /** Ceramic fill cooling tower.*/ kIfcCoolingTowerTypeEnum_CERAMIC, /** Crossflow cooling tower.*/ kIfcCoolingTowerTypeEnum_CROSSFLOW, /** Other type of cooling tower.*/ kIfcCoolingTowerTypeEnum_OTHER, kIfcCoolingTowerTypeEnum_NOTKNOWN, kIfcCoolingTowerTypeEnum_UNSET, /** The value is unset.*/ kIfcCoolingTowerTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcCoolingTowerTypeEnum& getUnset() { static OdIfc2x_final::IfcCoolingTowerTypeEnum nullEnum = OdIfc2x_final::kIfcCoolingTowerTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Enumeration defining the typical types of Chillers classified by their method of heat rejection. */ enum IfcChillerTypeEnum { /** Air cooled chiller.*/ kIfcChillerTypeEnum_AIRCOOLED, /** Water cooled chiller.*/ kIfcChillerTypeEnum_WATERCOOLED, /** Heat recovery chiller.*/ kIfcChillerTypeEnum_HEATRECOVERY, kIfcChillerTypeEnum_OTHER, /** Unknown chiller type.*/ kIfcChillerTypeEnum_NOTKNOWN, kIfcChillerTypeEnum_UNSET, /** The value is unset.*/ kIfcChillerTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcChillerTypeEnum& getUnset() { static OdIfc2x_final::IfcChillerTypeEnum nullEnum = OdIfc2x_final::kIfcChillerTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Enumeration defining the typical types of boilers. */ enum IfcBoilerTypeEnum { /** Hot water boiler.*/ kIfcBoilerTypeEnum_HOTWATER, /** Gas fired boiler.*/ kIfcBoilerTypeEnum_GASFIRED, /** Steam boiler.*/ kIfcBoilerTypeEnum_STEAM, kIfcBoilerTypeEnum_OTHER, kIfcBoilerTypeEnum_NOTKNOWN, kIfcBoilerTypeEnum_UNSET, /** The value is unset.*/ kIfcBoilerTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcBoilerTypeEnum& getUnset() { static OdIfc2x_final::IfcBoilerTypeEnum nullEnum = OdIfc2x_final::kIfcBoilerTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration is used to identify possible sources of energy. */ enum IfcEnergySourceEnum { /** Electricity.*/ kIfcEnergySourceEnum_ELECTRICITY, /** Natural gas.*/ kIfcEnergySourceEnum_NATURALGAS, /** Oil.*/ kIfcEnergySourceEnum_OIL, /** Liquified petroleum gas.*/ kIfcEnergySourceEnum_LIQUIFIEDPETROLEUMGAS, /** Propane.*/ kIfcEnergySourceEnum_PROPANE, /** Steam.*/ kIfcEnergySourceEnum_STEAM, /** Other type energy not defined above.*/ kIfcEnergySourceEnum_OTHER, /** Unknown energy source.*/ kIfcEnergySourceEnum_NOTKNOWN, kIfcEnergySourceEnum_UNSET, /** The value is unset.*/ kIfcEnergySourceEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcEnergySourceEnum& getUnset() { static OdIfc2x_final::IfcEnergySourceEnum nullEnum = OdIfc2x_final::kIfcEnergySourceEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Enumeration defining the typical types of compressors. */ enum IfcCompressorTypeEnum { /** Positive-displacement reciprocating compressor where the motor and compressor are contained within the same housing, with the motor shaft integral with the compressor crankshaft and the motor in contact with refrigerant.*/ kIfcCompressorTypeEnum_HERMETIC, /** Positive-displacement compressor using a piston driven by a connecting rod from a crankshaft.*/ kIfcCompressorTypeEnum_RECIPROCATING, kIfcCompressorTypeEnum_SCREW, kIfcCompressorTypeEnum_OTHER, /** Unknown compressor type.*/ kIfcCompressorTypeEnum_NOTKNOWN, kIfcCompressorTypeEnum_UNSET, /** The value is unset.*/ kIfcCompressorTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcCompressorTypeEnum& getUnset() { static OdIfc2x_final::IfcCompressorTypeEnum nullEnum = OdIfc2x_final::kIfcCompressorTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details The pressure classification of the fan. */ enum IfcFanPressureClassEnum { /** Class 1.*/ kIfcFanPressureClassEnum_CLASS1, /** Class 2.*/ kIfcFanPressureClassEnum_CLASS2, /** Class 3.*/ kIfcFanPressureClassEnum_CLASS3, /** Class 4.*/ kIfcFanPressureClassEnum_CLASS4, /** Other type of pressure classification.*/ kIfcFanPressureClassEnum_OTHER, /** Unknown pressure classification.*/ kIfcFanPressureClassEnum_NOTKNOWN, /** Unspecified pressure classification.*/ kIfcFanPressureClassEnum_UNSET, /** The value is unset.*/ kIfcFanPressureClassEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcFanPressureClassEnum& getUnset() { static OdIfc2x_final::IfcFanPressureClassEnum nullEnum = OdIfc2x_final::kIfcFanPressureClassEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details The pressure classification of the fan. */ enum IfcFanWheelTypeEnum { /** Forward curved.*/ kIfcFanWheelTypeEnum_FORWARDCURVED, /** Backward curved.*/ kIfcFanWheelTypeEnum_BACKWARDCURVED, /** Airfoil.*/ kIfcFanWheelTypeEnum_AIRFOIL, /** Propeller.*/ kIfcFanWheelTypeEnum_PROPELLER, /** Vaneaxial.*/ kIfcFanWheelTypeEnum_VANEAXIAL, /** Plug.*/ kIfcFanWheelTypeEnum_PLUG, /** Other type of fan wheel type.*/ kIfcFanWheelTypeEnum_OTHER, /** Unknown fan wheel type.*/ kIfcFanWheelTypeEnum_NOTKNOWN, /** Unspecified fan wheel type.*/ kIfcFanWheelTypeEnum_UNSET, /** The value is unset.*/ kIfcFanWheelTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcFanWheelTypeEnum& getUnset() { static OdIfc2x_final::IfcFanWheelTypeEnum nullEnum = OdIfc2x_final::kIfcFanWheelTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details The discharge arrangement of the fan. */ enum IfcFanDischargeTypeEnum { /** Duct*/ kIfcFanDischargeTypeEnum_DUCT, /** Screen.*/ kIfcFanDischargeTypeEnum_SCREEN, /** None.*/ kIfcFanDischargeTypeEnum_NONE, /** Other type of fan discharge.*/ kIfcFanDischargeTypeEnum_OTHER, /** Unknown fan discharge.*/ kIfcFanDischargeTypeEnum_NOTKNOWN, /** Unspecified fan discharge.*/ kIfcFanDischargeTypeEnum_UNSET, /** The value is unset.*/ kIfcFanDischargeTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcFanDischargeTypeEnum& getUnset() { static OdIfc2x_final::IfcFanDischargeTypeEnum nullEnum = OdIfc2x_final::kIfcFanDischargeTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details The wheel arrangement of the fan (primarily applicable to centrifugal fans only). */ enum IfcFanArrangementEnum { /** Top horizontal discharge.*/ kIfcFanArrangementEnum_TOPHORIZONTAL, /** Top angular down discharge.*/ kIfcFanArrangementEnum_TOPANGULARDOWN, /** Downblast discharge.*/ kIfcFanArrangementEnum_DOWNBLAST, /** Bottom angular down discharge.*/ kIfcFanArrangementEnum_BOTTOMANGULARDOWN, /** Bottom horizontal discharge.*/ kIfcFanArrangementEnum_BOTTOMHORIZONTAL, /** Bottom angular up discharge.*/ kIfcFanArrangementEnum_BOTTOMANGULARUP, /** Upblast discharge.*/ kIfcFanArrangementEnum_UPBLAST, /** Top angular up discharge.*/ kIfcFanArrangementEnum_TOPANGULARUP, /** Other type of fan arrangement.*/ kIfcFanArrangementEnum_OTHER, /** Unknown fan arrangement.*/ kIfcFanArrangementEnum_NOTKNOWN, /** Unspecified fan arrangement.*/ kIfcFanArrangementEnum_UNSET, /** The value is unset.*/ kIfcFanArrangementEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcFanArrangementEnum& getUnset() { static OdIfc2x_final::IfcFanArrangementEnum nullEnum = OdIfc2x_final::kIfcFanArrangementEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details The fan wheel rotation (primarily applicable to centrifugal fans only). */ enum IfcFanRotationEnum { /** Clockwise.*/ kIfcFanRotationEnum_CLOCKWISE, /** Counter-clockwise.*/ kIfcFanRotationEnum_COUNTERCLOCKWISE, /** Other type of fan rotation.*/ kIfcFanRotationEnum_OTHER, /** Unknown fan rotation.*/ kIfcFanRotationEnum_NOTKNOWN, /** Unspecified fan rotation.*/ kIfcFanRotationEnum_UNSET, /** The value is unset.*/ kIfcFanRotationEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcFanRotationEnum& getUnset() { static OdIfc2x_final::IfcFanRotationEnum nullEnum = OdIfc2x_final::kIfcFanRotationEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details The fan drive arrangement (primarily applicable to centrifugal fans only). */ enum IfcFanDriveArrangementEnum { /** ARRANGEMENT1*/ kIfcFanDriveArrangementEnum_ARRANGEMENT1, /** ARRANGEMENT2*/ kIfcFanDriveArrangementEnum_ARRANGEMENT2, /** ARRANGEMENT3*/ kIfcFanDriveArrangementEnum_ARRANGEMENT3, /** ARRANGEMENT4*/ kIfcFanDriveArrangementEnum_ARRANGEMENT4, /** ARRANGEMENT5*/ kIfcFanDriveArrangementEnum_ARRANGEMENT5, /** ARRANGEMENT6*/ kIfcFanDriveArrangementEnum_ARRANGEMENT6, /** ARRANGEMENT7*/ kIfcFanDriveArrangementEnum_ARRANGEMENT7, /** ARRANGEMENT8*/ kIfcFanDriveArrangementEnum_ARRANGEMENT8, /** ARRANGEMENT9*/ kIfcFanDriveArrangementEnum_ARRANGEMENT9, /** ARRANGEMENT10*/ kIfcFanDriveArrangementEnum_ARRANGEMENT10, /** Other type of fan drive arrangement.*/ kIfcFanDriveArrangementEnum_OTHER, /** Unknown fan drive arrangement.*/ kIfcFanDriveArrangementEnum_NOTKNOWN, /** Unspecified fan drive arrangement.*/ kIfcFanDriveArrangementEnum_UNSET, /** The value is unset.*/ kIfcFanDriveArrangementEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcFanDriveArrangementEnum& getUnset() { static OdIfc2x_final::IfcFanDriveArrangementEnum nullEnum = OdIfc2x_final::kIfcFanDriveArrangementEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details The way the motor is connected. */ enum IfcMoterConnectionTypeEnum { /** Direct drive.*/ kIfcMoterConnectionTypeEnum_DIRECTDRIVE, /** Belt drive.*/ kIfcMoterConnectionTypeEnum_BELTDRIVE, /** Coupling.*/ kIfcMoterConnectionTypeEnum_COUPLING, /** Other type of motor connection.*/ kIfcMoterConnectionTypeEnum_OTHER, /** Unknown motor connection type.*/ kIfcMoterConnectionTypeEnum_NOTKNOWN, /** Unspecified motor connection type.*/ kIfcMoterConnectionTypeEnum_UNSET, /** The value is unset.*/ kIfcMoterConnectionTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcMoterConnectionTypeEnum& getUnset() { static OdIfc2x_final::IfcMoterConnectionTypeEnum nullEnum = OdIfc2x_final::kIfcMoterConnectionTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details The way the fan is mounted. */ enum IfcFanMountingTypeEnum { /** Manufactured curb.*/ kIfcFanMountingTypeEnum_MANUFACTUREDCURB, /** Field erected curb.*/ kIfcFanMountingTypeEnum_FIELDERECTEDCURB, /** Concrete pad.*/ kIfcFanMountingTypeEnum_CONCRETEPAD, /** Suspended.*/ kIfcFanMountingTypeEnum_SUSPENDED, /** Wall mounted.*/ kIfcFanMountingTypeEnum_WALLMOUNTED, /** Duct mounted.*/ kIfcFanMountingTypeEnum_DUCTMOUNTED, /** Other type of fan mounting.*/ kIfcFanMountingTypeEnum_OTHER, /** Unknown fan mounting.*/ kIfcFanMountingTypeEnum_NOTKNOWN, /** Unspecified fan mounting.*/ kIfcFanMountingTypeEnum_UNSET, /** The value is unset.*/ kIfcFanMountingTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcFanMountingTypeEnum& getUnset() { static OdIfc2x_final::IfcFanMountingTypeEnum nullEnum = OdIfc2x_final::kIfcFanMountingTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Defines general types of pumps. */ enum IfcPumpTypeEnum { /** A Circulator pump is a generic low-pressure, low-capacity pump. It may have a wet rotor and may be driven by a flexible-coupled motor.*/ kIfcPumpTypeEnum_CIRCULATOR, /** An End Suction pump, when mounted horizontally, has a single horizontal inlet on the impeller suction side and a vertical discharge. It may have a direct or close-coupled motor.*/ kIfcPumpTypeEnum_ENDSUCTION, /** A Split Case pump, when mounted horizontally, has an inlet and outlet on each side of the impeller. The impeller can be easily accessed by removing the front of the impeller casing. It may have a direct or close-coupled motor.*/ kIfcPumpTypeEnum_SPLITCASE, /** A Vertical Inline pump has the pump and motor close-coupled on the pump casing. The pump depends on the connected, horizontal piping for support, with the suction and discharge along the piping axis.*/ kIfcPumpTypeEnum_VERTICALINLINE, /** A Vertical Turbine pump has a motor mounted vertically on the pump casing for either wet-pit sump mounting or dry-well mounting.*/ kIfcPumpTypeEnum_VERTICALTURBINE, kIfcPumpTypeEnum_OTHER, /** Unknown pump type.*/ kIfcPumpTypeEnum_NOTKNOWN, kIfcPumpTypeEnum_UNSET, /** The value is unset.*/ kIfcPumpTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcPumpTypeEnum& getUnset() { static OdIfc2x_final::IfcPumpTypeEnum nullEnum = OdIfc2x_final::kIfcPumpTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Defines general types of pump bases. */ enum IfcPumpBaseTypeEnum { /** FRAME*/ kIfcPumpBaseTypeEnum_FRAME, /** BASE*/ kIfcPumpBaseTypeEnum_BASE, /** INLINE*/ kIfcPumpBaseTypeEnum_INLINE, /** Other type of pump base.*/ kIfcPumpBaseTypeEnum_OTHER, /** Unknown pump base type.*/ kIfcPumpBaseTypeEnum_NOTKNOWN, /** Unspecified pump base type.*/ kIfcPumpBaseTypeEnum_UNSET, /** The value is unset.*/ kIfcPumpBaseTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcPumpBaseTypeEnum& getUnset() { static OdIfc2x_final::IfcPumpBaseTypeEnum nullEnum = OdIfc2x_final::kIfcPumpBaseTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the different types of distribution flow elements an IfcDistributionFlowElement object can fulfill. */ enum IfcDistributionFlowElementTypeEnum { /** Fluid Flow distribution element*/ kIfcDistributionFlowElementTypeEnum_FLUIDFLOW, /** User-defined flow element*/ kIfcDistributionFlowElementTypeEnum_USERDEFINED, /** Undefined flow element*/ kIfcDistributionFlowElementTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcDistributionFlowElementTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcDistributionFlowElementTypeEnum& getUnset() { static OdIfc2x_final::IfcDistributionFlowElementTypeEnum nullEnum = OdIfc2x_final::kIfcDistributionFlowElementTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the type of thermal load for spaces or zones, as derived from various use cases. */ enum IfcThermalLoadTypeEnum { kIfcThermalLoadTypeEnum_PEOPLESENSIBLE, kIfcThermalLoadTypeEnum_PEOPLELATENT, kIfcThermalLoadTypeEnum_LIGHTING, kIfcThermalLoadTypeEnum_EQUIPMENTSENSIBLE, kIfcThermalLoadTypeEnum_EQUIPMENTLATENT, kIfcThermalLoadTypeEnum_VENTILATIONINDOORAIR, kIfcThermalLoadTypeEnum_VENTILATIONOUTSIDEAIR, kIfcThermalLoadTypeEnum_RECIRCULATEDAIR, kIfcThermalLoadTypeEnum_EXHAUSTAIR, /** Loads from the air exchange rate.*/ kIfcThermalLoadTypeEnum_AIREXCHANGERATE, kIfcThermalLoadTypeEnum_DRYBULBTEMPERATURE, kIfcThermalLoadTypeEnum_RELATIVEHUMIDITY, kIfcThermalLoadTypeEnum_INFILTRATIONSENSIBLE, kIfcThermalLoadTypeEnum_INFILTRATIONLATENT, kIfcThermalLoadTypeEnum_OTHER, kIfcThermalLoadTypeEnum_NOTKNOWN, /** The value is unset.*/ kIfcThermalLoadTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcThermalLoadTypeEnum& getUnset() { static OdIfc2x_final::IfcThermalLoadTypeEnum nullEnum = OdIfc2x_final::kIfcThermalLoadTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines whether the thermal use case is a requirement for a particular thermal space quality or a criteria. */ enum IfcRequirementOrCriteriaEnum { /** REQUIREMENT.*/ kIfcRequirementOrCriteriaEnum_REQUIREMENT, /** CRITERIA.*/ kIfcRequirementOrCriteriaEnum_CRITERIA, /** NOTDEFINED.*/ kIfcRequirementOrCriteriaEnum_NOTDEFINED, /** The value is unset.*/ kIfcRequirementOrCriteriaEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcRequirementOrCriteriaEnum& getUnset() { static OdIfc2x_final::IfcRequirementOrCriteriaEnum nullEnum = OdIfc2x_final::kIfcRequirementOrCriteriaEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the thermal use cases as either being a loss or a gain to the space. */ enum IfcLossOrGainEnum { /** LOSS.*/ kIfcLossOrGainEnum_LOSS, /** GAIN.*/ kIfcLossOrGainEnum_GAIN, /** NOTDEFINED.*/ kIfcLossOrGainEnum_NOTDEFINED, /** The value is unset.*/ kIfcLossOrGainEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcLossOrGainEnum& getUnset() { static OdIfc2x_final::IfcLossOrGainEnum nullEnum = OdIfc2x_final::kIfcLossOrGainEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the different types of available electrical current. */ enum IfcElectricCurrentEnum { /** Alternating current (AC).*/ kIfcElectricCurrentEnum_ALTERNATING, /** Direct current (DC).*/ kIfcElectricCurrentEnum_DIRECT, /** Undefined electrical current.*/ kIfcElectricCurrentEnum_NOTDEFINED, /** The value is unset.*/ kIfcElectricCurrentEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcElectricCurrentEnum& getUnset() { static OdIfc2x_final::IfcElectricCurrentEnum nullEnum = OdIfc2x_final::kIfcElectricCurrentEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details An enumerated list of the types of risk factors that are associated with maintenance work on an asset. */ enum IfcRiskTypeEnum { /** HEALTHANDSAFETY*/ kIfcRiskTypeEnum_HEALTHANDSAFETY, /** HAZARD*/ kIfcRiskTypeEnum_HAZARD, /** INSURANCE*/ kIfcRiskTypeEnum_INSURANCE, /** BUSINESS*/ kIfcRiskTypeEnum_BUSINESS, /** GENERALRISKFACTOR*/ kIfcRiskTypeEnum_GENERALRISKFACTOR, /** USERDEFINED*/ kIfcRiskTypeEnum_USERDEFINED, /** NOTDEFINED*/ kIfcRiskTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcRiskTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcRiskTypeEnum& getUnset() { static OdIfc2x_final::IfcRiskTypeEnum nullEnum = OdIfc2x_final::kIfcRiskTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details IfcInventoryTypeEnum defines the types of inventory that can be defined. */ enum IfcInventoryTypeEnum { /** A collection of asset instances of type IfcAsset.*/ kIfcInventoryTypeEnum_ASSETINVENTORY, /** A collection of space instances of type IfcSpace.*/ kIfcInventoryTypeEnum_SPACEINVENTORY, /** A collection of furniture instances of type IfcFurnishingElement.*/ kIfcInventoryTypeEnum_FURNITUREINVENTORY, /** The value is unset.*/ kIfcInventoryTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcInventoryTypeEnum& getUnset() { static OdIfc2x_final::IfcInventoryTypeEnum nullEnum = OdIfc2x_final::kIfcInventoryTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Values that may be assigned to cost status to indicate how element calculations are to be carried out. */ enum IfcCostUseEnum { /** EXTENSIONONLY*/ kIfcCostUseEnum_EXTENSIONONLY, /** ELEMENTONLY*/ kIfcCostUseEnum_ELEMENTONLY, /** ELEMENTSETEXTENSIONCALC*/ kIfcCostUseEnum_ELEMENTSETEXTENSIONCALC, /** EXTENSIONSETELEMENTCALC*/ kIfcCostUseEnum_EXTENSIONSETELEMENTCALC, /** USERDEFINED*/ kIfcCostUseEnum_USERDEFINED, /** NOTDEFINED*/ kIfcCostUseEnum_NOTDEFINED, /** The value is unset.*/ kIfcCostUseEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcCostUseEnum& getUnset() { static OdIfc2x_final::IfcCostUseEnum nullEnum = OdIfc2x_final::kIfcCostUseEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Values that the status of a change order may be given. */ enum IfcChangeOrderStatusEnum { /** PROPOSING.*/ kIfcChangeOrderStatusEnum_PROPOSING, /** PROPOSED.*/ kIfcChangeOrderStatusEnum_PROPOSED, /** REQUESTED.*/ kIfcChangeOrderStatusEnum_REQUESTED, /** BEINGAPPROVED.*/ kIfcChangeOrderStatusEnum_BEINGAPPROVED, /** PLANNING.*/ kIfcChangeOrderStatusEnum_PLANNING, /** WORKSTARTED.*/ kIfcChangeOrderStatusEnum_WORKSTARTED, /** WORKDELAYED.*/ kIfcChangeOrderStatusEnum_WORKDELAYED, /** WORKDONE.*/ kIfcChangeOrderStatusEnum_WORKDONE, /** USERDEFINED.*/ kIfcChangeOrderStatusEnum_USERDEFINED, /** NOTDEFINED.*/ kIfcChangeOrderStatusEnum_NOTDEFINED, /** The value is unset.*/ kIfcChangeOrderStatusEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcChangeOrderStatusEnum& getUnset() { static OdIfc2x_final::IfcChangeOrderStatusEnum nullEnum = OdIfc2x_final::kIfcChangeOrderStatusEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Values that describe the potential status that a purchase order may be assigned. */ enum IfcPurchaseOrderStatusEnum { /** REQUESTED.*/ kIfcPurchaseOrderStatusEnum_REQUESTED, /** BEINGAPPROVED.*/ kIfcPurchaseOrderStatusEnum_BEINGAPPROVED, /** ISSUED.*/ kIfcPurchaseOrderStatusEnum_ISSUED, /** RECEIVED.*/ kIfcPurchaseOrderStatusEnum_RECEIVED, /** ITEMSRECEIVED.*/ kIfcPurchaseOrderStatusEnum_ITEMSRECEIVED, /** USERDEFINED.*/ kIfcPurchaseOrderStatusEnum_USERDEFINED, /** NOTDEFINED.*/ kIfcPurchaseOrderStatusEnum_NOTDEFINED, /** The value is unset.*/ kIfcPurchaseOrderStatusEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcPurchaseOrderStatusEnum& getUnset() { static OdIfc2x_final::IfcPurchaseOrderStatusEnum nullEnum = OdIfc2x_final::kIfcPurchaseOrderStatusEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Values that can be assigned to determine the status of a work order. */ enum IfcWorkOrderStatusEnum { /** REQUESTED.*/ kIfcWorkOrderStatusEnum_REQUESTED, /** BEINGAPPROVED.*/ kIfcWorkOrderStatusEnum_BEINGAPPROVED, /** PLANNING.*/ kIfcWorkOrderStatusEnum_PLANNING, /** WORKSTARTED.*/ kIfcWorkOrderStatusEnum_WORKSTARTED, /** WORKDELAYED.*/ kIfcWorkOrderStatusEnum_WORKDELAYED, /** WORKDONE.*/ kIfcWorkOrderStatusEnum_WORKDONE, /** USERDEFINED.*/ kIfcWorkOrderStatusEnum_USERDEFINED, /** NOTDEFINED.*/ kIfcWorkOrderStatusEnum_NOTDEFINED, /** The value is unset.*/ kIfcWorkOrderStatusEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcWorkOrderStatusEnum& getUnset() { static OdIfc2x_final::IfcWorkOrderStatusEnum nullEnum = OdIfc2x_final::kIfcWorkOrderStatusEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details An enumerated list of the types of risk factors that are associated with carrying out a work order. */ enum IfcWorkOrderRiskTypeEnum { /** HEALTHANDSAFETY.*/ kIfcWorkOrderRiskTypeEnum_HEALTHANDSAFETY, /** HAZARDS.*/ kIfcWorkOrderRiskTypeEnum_HAZARDS, /** INSURANCE.*/ kIfcWorkOrderRiskTypeEnum_INSURANCE, /** GENERALRISKFACTOR.*/ kIfcWorkOrderRiskTypeEnum_GENERALRISKFACTOR, /** USERDEFINED.*/ kIfcWorkOrderRiskTypeEnum_USERDEFINED, /** NOTDEFINED.*/ kIfcWorkOrderRiskTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcWorkOrderRiskTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcWorkOrderRiskTypeEnum& getUnset() { static OdIfc2x_final::IfcWorkOrderRiskTypeEnum nullEnum = OdIfc2x_final::kIfcWorkOrderRiskTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details IfcOccupantTypeEnum defines the types of occupant from which the type required can be selected. */ enum IfcOccupantTypeEnum { /** Actor that owns a property.*/ kIfcOccupantTypeEnum_OWNER, /** Actor receiving the lease of a property from a lessor.*/ kIfcOccupantTypeEnum_LESSEE, /** Actor renting the use of a property fro a period of time.*/ kIfcOccupantTypeEnum_TENANT, /** Actor receiving the assignment of a property agreement from an assignor.*/ kIfcOccupantTypeEnum_ASSIGNEE, /** Undefined type.*/ kIfcOccupantTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcOccupantTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcOccupantTypeEnum& getUnset() { static OdIfc2x_final::IfcOccupantTypeEnum nullEnum = OdIfc2x_final::kIfcOccupantTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the valid types of permeable coverings. */ enum IfcPermeableCoveringOperationEnum { /** Protective screen of metal bars or wires.*/ kIfcPermeableCoveringOperationEnum_GRILL, /** Set of fixed or movable strips of wood, metal, etc. arranged to let air in while keeping light or rain out.*/ kIfcPermeableCoveringOperationEnum_LOUVER, /** Upright, fixed or movable, sometimes folding framework used for protection against heat, light, access or similar.*/ kIfcPermeableCoveringOperationEnum_SCREEN, /** User defined permeable covering type.*/ kIfcPermeableCoveringOperationEnum_USERDEFINED, /** No information available.*/ kIfcPermeableCoveringOperationEnum_NOTDEFINED, /** The value is unset.*/ kIfcPermeableCoveringOperationEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcPermeableCoveringOperationEnum& getUnset() { static OdIfc2x_final::IfcPermeableCoveringOperationEnum nullEnum = OdIfc2x_final::kIfcPermeableCoveringOperationEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the basic ways to describe the joining of elements. */ enum IfcJointEnum { /** EXPANSION_JOINT.*/ kIfcJointEnum_EXPANSION_JOINT, /** EDGE_JOINT.*/ kIfcJointEnum_EDGE_JOINT, /** CONTROL_JOINT.*/ kIfcJointEnum_CONTROL_JOINT, /** NOTDEFINED.*/ kIfcJointEnum_NOTDEFINED, /** The value is unset.*/ kIfcJointEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcJointEnum& getUnset() { static OdIfc2x_final::IfcJointEnum nullEnum = OdIfc2x_final::kIfcJointEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the different types of IfcRailing or IfcRailingType that can be predefined using the enumeration values. */ enum IfcRailingTypeEnum { /** A type of railing designed to serve as an optional structural support for loads applied by human occupants (at hand height). Generally located adjacent to ramps and stairs. Generally floor or wall mounted.*/ kIfcRailingTypeEnum_HANDRAIL, /** A type of railing designed to guard human or vehicle occupants from falling off a stair, ramp or landing where there is a vertical drop at the edge of such floors/landings, or to provide restraint to an errant road vehicle, installed on the central reserve of or alongside a road.*/ kIfcRailingTypeEnum_GUARDRAIL, /** Guardrail located at the edge of a floor, rather then a stair or ramp. Examples are balustrades at roof-tops or balconies, or along a bridge or on top of a retaining wall.*/ kIfcRailingTypeEnum_BALUSTRADE, /** User-defined railing element, a term to identify the user type is given by the attribute IfcRailing.ObjectType.*/ kIfcRailingTypeEnum_USERDEFINED, /** Undefined railing element, no type information available.*/ kIfcRailingTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcRailingTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcRailingTypeEnum& getUnset() { static OdIfc2x_final::IfcRailingTypeEnum nullEnum = OdIfc2x_final::kIfcRailingTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Enumeration defining the valid types of Built-In that can be predefined using the enumeration values. */ enum IfcBuiltInTypeEnum { /** ACCESSORY.*/ kIfcBuiltInTypeEnum_ACCESSORY, /** CABINET.*/ kIfcBuiltInTypeEnum_CABINET, /** COUNTER.*/ kIfcBuiltInTypeEnum_COUNTER, /** SHELF.*/ kIfcBuiltInTypeEnum_SHELF, /** USERDEFINED.*/ kIfcBuiltInTypeEnum_USERDEFINED, /** NOTDEFINED.*/ kIfcBuiltInTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcBuiltInTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcBuiltInTypeEnum& getUnset() { static OdIfc2x_final::IfcBuiltInTypeEnum nullEnum = OdIfc2x_final::kIfcBuiltInTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the different types of motor windings. */ enum IfcMotorWindingEnum { /** Request was made through email.*/ kIfcMotorWindingEnum_SYNCHRONOUS, /** Request was made through facsimile.*/ kIfcMotorWindingEnum_ASYNCHRONOUS, /** Request was made verbally over a telephone.*/ kIfcMotorWindingEnum_SERIESWOUND, /** Request was made through postal mail.*/ kIfcMotorWindingEnum_PARALLELWOUND, /** Request was made verbally in person.*/ kIfcMotorWindingEnum_OTHER, /** Undefined motor winding type.*/ kIfcMotorWindingEnum_NOTDEFINED, /** Unknown motor winding type.*/ kIfcMotorWindingEnum_NOTKNOWN, /** Unspecified motor winding type.*/ kIfcMotorWindingEnum_UNSET, /** The value is unset.*/ kIfcMotorWindingEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcMotorWindingEnum& getUnset() { static OdIfc2x_final::IfcMotorWindingEnum nullEnum = OdIfc2x_final::kIfcMotorWindingEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the different types of motor housings. */ enum IfcMotorHousingEnum { /** Sealed.*/ kIfcMotorHousingEnum_SEALED, /** Open.*/ kIfcMotorHousingEnum_OPEN, /** Other.*/ kIfcMotorHousingEnum_OTHER, /** Unknown motor housing type.*/ kIfcMotorHousingEnum_NOTKNOWN, /** Unspecified motor housing type.*/ kIfcMotorHousingEnum_UNSET, /** The value is unset.*/ kIfcMotorHousingEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcMotorHousingEnum& getUnset() { static OdIfc2x_final::IfcMotorHousingEnum nullEnum = OdIfc2x_final::kIfcMotorHousingEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details The IfcOutletTypeEnum defines the range of different types of outlet that can be specified. */ enum IfcOutletTypeEnum { /** An outlet used for connecting electrical devices requiring power.*/ kIfcOutletTypeEnum_POWEROUTLET, /** User-defined type.*/ kIfcOutletTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcOutletTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcOutletTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcOutletTypeEnum& getUnset() { static OdIfc2x_final::IfcOutletTypeEnum nullEnum = OdIfc2x_final::kIfcOutletTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the different types of electrical appliances an IfcElectricalAppliance object can fulfill. */ enum IfcElectricalApplianceTypeEnum { /** Computer electrical appliance*/ kIfcElectricalApplianceTypeEnum_COMPUTER, /** Copier electrical appliance*/ kIfcElectricalApplianceTypeEnum_COPIER, /** Facsimile electrical appliance*/ kIfcElectricalApplianceTypeEnum_FACSIMILE, /** Printer electrical appliance*/ kIfcElectricalApplianceTypeEnum_PRINTER, /** Radiant heater*/ kIfcElectricalApplianceTypeEnum_RADIANTHEATER, /** Telephone electrical appliance*/ kIfcElectricalApplianceTypeEnum_TELEPHONE, /** User-defined electrical appliance*/ kIfcElectricalApplianceTypeEnum_USERDEFINED, /** Undefined electrical appliance*/ kIfcElectricalApplianceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcElectricalApplianceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcElectricalApplianceTypeEnum& getUnset() { static OdIfc2x_final::IfcElectricalApplianceTypeEnum nullEnum = OdIfc2x_final::kIfcElectricalApplianceTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Designation of the origination of the work order and consequently of the type of work being done. */ enum IfcMaintenanceTypeEnum { /** SCHEDULED.*/ kIfcMaintenanceTypeEnum_SCHEDULED, /** CORRECTIVE.*/ kIfcMaintenanceTypeEnum_CORRECTIVE, /** PLANNEDCORRECTIVE.*/ kIfcMaintenanceTypeEnum_PLANNEDCORRECTIVE, /** CONDITIONBASED.*/ kIfcMaintenanceTypeEnum_CONDITIONBASED, /** USERDEFINED.*/ kIfcMaintenanceTypeEnum_USERDEFINED, /** NOTDEFINED.*/ kIfcMaintenanceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcMaintenanceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcMaintenanceTypeEnum& getUnset() { static OdIfc2x_final::IfcMaintenanceTypeEnum nullEnum = OdIfc2x_final::kIfcMaintenanceTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details Priority values that may be assigned to a fault in respect of carrying out a work order. */ enum IfcPriorityEnum { /** High priority.*/ kIfcPriorityEnum_HIGH, /** Medium priority.*/ kIfcPriorityEnum_MEDIUM, /** Low priority.*/ kIfcPriorityEnum_LOW, /** The value is unset.*/ kIfcPriorityEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcPriorityEnum& getUnset() { static OdIfc2x_final::IfcPriorityEnum nullEnum = OdIfc2x_final::kIfcPriorityEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details The IfcActuatorTypeEnum defines the range of different types of actuator that can be specified. */ enum IfcActuatorTypeEnum { /** A device that electrically actuates a control element.*/ kIfcActuatorTypeEnum_ELECTRICACTUATOR, /** A device that pneumatically actuates a control element.*/ kIfcActuatorTypeEnum_PNEUMATICACTUATOR, /** A device that hydraulically actuates a control element.*/ kIfcActuatorTypeEnum_HYDRAULICACTUATOR, /** A device that manually actuates a control element.*/ kIfcActuatorTypeEnum_HANDOPERATEDACTUATOR, /** User-defined type.*/ kIfcActuatorTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcActuatorTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcActuatorTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcActuatorTypeEnum& getUnset() { static OdIfc2x_final::IfcActuatorTypeEnum nullEnum = OdIfc2x_final::kIfcActuatorTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the different states for failure for an instance of IfcActuator. */ enum IfcActuatorFailPositionEnum { /** Actuator fails to the open position.*/ kIfcActuatorFailPositionEnum_FAILOPEN, /** Actuator fails to the closed position.*/ kIfcActuatorFailPositionEnum_FAILCLOSED, /** User-defined fail position.*/ kIfcActuatorFailPositionEnum_USERDEFINED, /** Undefined fail position.*/ kIfcActuatorFailPositionEnum_NOTDEFINED, /** The value is unset.*/ kIfcActuatorFailPositionEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcActuatorFailPositionEnum& getUnset() { static OdIfc2x_final::IfcActuatorFailPositionEnum nullEnum = OdIfc2x_final::kIfcActuatorFailPositionEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details The IfcSensorTypeEnum defines the range of different types of sensor that can be specified. */ enum IfcSensorTypeEnum { /** Hvac sensor.*/ kIfcSensorTypeEnum_HVACSENSOR, /** User-defined type.*/ kIfcSensorTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcSensorTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcSensorTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcSensorTypeEnum& getUnset() { static OdIfc2x_final::IfcSensorTypeEnum nullEnum = OdIfc2x_final::kIfcSensorTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration identifies different types of valves. */ enum IfcValveEnum { /** Automated valve.*/ kIfcValveEnum_AUTOMATED, /** Angle valve.*/ kIfcValveEnum_ANGLE, /** AWWA valve.*/ kIfcValveEnum_AWWA, /** Ball valve.*/ kIfcValveEnum_BALL, /** Butterfly valve.*/ kIfcValveEnum_BUTTERFLY, /** Check valve.*/ kIfcValveEnum_CHECK, /** Diverter valve.*/ kIfcValveEnum_DIVERTER, /** Gate valve.*/ kIfcValveEnum_GATE, /** Globe valve.*/ kIfcValveEnum_GLOBE, /** Nace valve.*/ kIfcValveEnum_NACE, /** Needle valve.*/ kIfcValveEnum_NEEDLE, /** Plug valve.*/ kIfcValveEnum_PLUG, /** Pipeline valve.*/ kIfcValveEnum_PIPELINE, /** Safety valve.*/ kIfcValveEnum_SAFETY, /** Threeway valve.*/ kIfcValveEnum_THREEWAY, /** ULFM valve.*/ kIfcValveEnum_ULFM, /** User-defined valve.*/ kIfcValveEnum_USERDEFINED, /** Undefined valve.*/ kIfcValveEnum_NOTDEFINED, /** The value is unset.*/ kIfcValveEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcValveEnum& getUnset() { static OdIfc2x_final::IfcValveEnum nullEnum = OdIfc2x_final::kIfcValveEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration identifies different types of air terminal boxes. */ enum IfcAirTerminalBoxEnum { /** Variable air volume terminal box.*/ kIfcAirTerminalBoxEnum_VARIABLEAIRVOLUME, /** Constant volume terminal box.*/ kIfcAirTerminalBoxEnum_CONSTANTVOLUME, /** Variable air volume with reheat terminal box.*/ kIfcAirTerminalBoxEnum_VARIABLEAIRVOLUMEREHEAT, /** Constant volume with reheat terminal box.*/ kIfcAirTerminalBoxEnum_CONSTANTVOLUMEREHEAT, /** Variable air volume dual duct terminal box.*/ kIfcAirTerminalBoxEnum_VARIABLEAIRVOLUMEDUALDUCT, /** Constant volume dual duct terminal box.*/ kIfcAirTerminalBoxEnum_CONSTANTVOLUMEDUALDUCT, /** Fan-powered terminal box.*/ kIfcAirTerminalBoxEnum_FANPOWERED, /** User-defined terminal box.*/ kIfcAirTerminalBoxEnum_USERDEFINED, /** Undefined terminal box.*/ kIfcAirTerminalBoxEnum_NOTDEFINED, /** The value is unset.*/ kIfcAirTerminalBoxEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcAirTerminalBoxEnum& getUnset() { static OdIfc2x_final::IfcAirTerminalBoxEnum nullEnum = OdIfc2x_final::kIfcAirTerminalBoxEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the various types of damper */ enum IfcDamperTypeEnum { /** Fire damper used to prevent the spread of fire for a specified duration. Commonly operated by fusable link that melts above a certain temperature.*/ kIfcDamperTypeEnum_FIREDAMPER, /** Smoke damper used to prevent the spread of smoke. Commonly operated by a smoke detector of a building automation system.*/ kIfcDamperTypeEnum_SMOKEDAMPER, /** Combination fire and smoke damper used to prevent the spread of fire and smoke. Commonly operated by a fusable link and a smoke detector.*/ kIfcDamperTypeEnum_FIRESMOKEDAMPER, /** Damper used for purposes of manually balancing pressure differences. Commonly operated by mechanical adjustment.*/ kIfcDamperTypeEnum_BACKDRAFTDAMPER, /** Control damper used to modulate the flow of air by adjusting the position of the blades. Commonly operated by an actuator of a building automation system.*/ kIfcDamperTypeEnum_CONTROLDAMPER, /** Louver.*/ kIfcDamperTypeEnum_LOUVER, /** User-defined damper.*/ kIfcDamperTypeEnum_USERDEFINED, /** Undefined damper.*/ kIfcDamperTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcDamperTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcDamperTypeEnum& getUnset() { static OdIfc2x_final::IfcDamperTypeEnum nullEnum = OdIfc2x_final::kIfcDamperTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { /** \details This enumeration defines the sizing methods used for an instance of IfcDamper. */ enum IfcDamperSizingMethodEnum { /** Nominal sizing method.*/ kIfcDamperSizingMethodEnum_NOMINAL, /** Exact sizing method.*/ kIfcDamperSizingMethodEnum_EXACT, /** User-defined sizing method.*/ kIfcDamperSizingMethodEnum_USERDEFINED, /** Undefined sizing method.*/ kIfcDamperSizingMethodEnum_NOTDEFINED, /** The value is unset.*/ kIfcDamperSizingMethodEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x_final::IfcDamperSizingMethodEnum& getUnset() { static OdIfc2x_final::IfcDamperSizingMethodEnum nullEnum = OdIfc2x_final::kIfcDamperSizingMethodEnum_unset; return nullEnum; } } } namespace OdIfc2x_final { } // namespace #include "TD_PackPop.h" #endif // _IFC2X_FINAL_ENUM_H