/////////////////////////////////////////////////////////////////////////////// // 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 _IFC2X3_ENUM_H #define _IFC2X3_ENUM_H #include "RxValue.h" #include "daiEnum.h" #include "Ifc2x3BuildOption.h" #include "TD_PackPush.h" namespace OdIfc2x3 { /** \details This enumeration type contains possible action sources. */ enum IfcActionSourceTypeEnum { /** The structure carries the dead load, which includes its own weight, the weight of any permanent non-structural partitions, built-in cupboards, floor surfacing materials and other finishes.*/ kIfcActionSourceTypeEnum_DEAD_LOAD_G, /** Completion.*/ kIfcActionSourceTypeEnum_COMPLETION_G1, /** All the movable objects in a building such as people, desks, cupboards and filing cabinets produce an imposed load on the structure. This loading may come and go with the result that its intensity will vary considerably. At one moment a room may be empty, yet at another packed with people.*/ kIfcActionSourceTypeEnum_LIVE_LOAD_Q, /** The magnitude of the snow load will depend upon the latitude and altitude of the site. In the lower latitudes no snow would be expected while in the high latitudes snow could last for six months or more.*/ kIfcActionSourceTypeEnum_SNOW_S, /** The wind acts both on the main structure and on the individual cladding units. The structure has to be braced to resist the horizontal load and anchored to the ground to prevent the whole building from being blown away, if the dead weight of the building is not sufficient to hold it down.*/ kIfcActionSourceTypeEnum_WIND_W, /** Presstressing load.*/ kIfcActionSourceTypeEnum_PRESTRESSING_P, /** If one part of a building settles more than another part, then stresses are set up in the structures.*/ kIfcActionSourceTypeEnum_SETTLEMENT_U, /** All building materials expand or contract with temperature change. Long continuous buildings will expand, and it is necessary to consider the expansion stresses.*/ kIfcActionSourceTypeEnum_TEMPERATURE_T, /** Earthquake loads affect the design of structures in areas of great seismic activity.*/ kIfcActionSourceTypeEnum_EARTHQUAKE_E, /** Fire action on the build facility.*/ kIfcActionSourceTypeEnum_FIRE, /** Load from impulse force.*/ kIfcActionSourceTypeEnum_IMPULSE, /** Impact force from an object hitting the facility.*/ kIfcActionSourceTypeEnum_IMPACT, /** Loads from transport.*/ kIfcActionSourceTypeEnum_TRANSPORT, /** Loads on the facility that occur during erection, but not after completion.*/ kIfcActionSourceTypeEnum_ERECTION, /** Propping*/ kIfcActionSourceTypeEnum_PROPPING, /** Loads from imperfections in the system.*/ kIfcActionSourceTypeEnum_SYSTEM_IMPERFECTION, /** Loads from shrinkage.*/ kIfcActionSourceTypeEnum_SHRINKAGE, /** Forces due to creep.*/ kIfcActionSourceTypeEnum_CREEP, /** Lack of fit.*/ kIfcActionSourceTypeEnum_LACK_OF_FIT, /** Buoyancy.*/ kIfcActionSourceTypeEnum_BUOYANCY, /** Loads from ice.*/ kIfcActionSourceTypeEnum_ICE, /** Current.*/ kIfcActionSourceTypeEnum_CURRENT, /** Loads from a wave hitting the structure.*/ kIfcActionSourceTypeEnum_WAVE, /** Rain and water on the structure.*/ kIfcActionSourceTypeEnum_RAIN, /** Brakes*/ kIfcActionSourceTypeEnum_BRAKES, /** User defined. See objectType for user defined type.*/ kIfcActionSourceTypeEnum_USERDEFINED, /** Not defined.*/ kIfcActionSourceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcActionSourceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcActionSourceTypeEnum& getUnset() { static OdIfc2x3::IfcActionSourceTypeEnum nullEnum = OdIfc2x3::kIfcActionSourceTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration type is used to distinguish between possible action types at a high level. It can be used for an automated definition of load combinations and for dimensioning. The contained items and their acronyms are adopted from the Eurocode standard. */ enum IfcActionTypeEnum { /** Permanent G*/ kIfcActionTypeEnum_PERMANENT_G, /** Variable Q*/ kIfcActionTypeEnum_VARIABLE_Q, /** Extraordinary A*/ kIfcActionTypeEnum_EXTRAORDINARY_A, /** User defined*/ kIfcActionTypeEnum_USERDEFINED, /** Not defined*/ kIfcActionTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcActionTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcActionTypeEnum& getUnset() { static OdIfc2x3::IfcActionTypeEnum nullEnum = OdIfc2x3::kIfcActionTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 manually actuates a control element.*/ kIfcActuatorTypeEnum_HANDOPERATEDACTUATOR, /** A device that hydraulically actuates a control element.*/ kIfcActuatorTypeEnum_HYDRAULICACTUATOR, /** A device that pneumatically actuates a control element.*/ kIfcActuatorTypeEnum_PNEUMATICACTUATOR, /** A device that thermostatically actuates a control element.*/ kIfcActuatorTypeEnum_THERMOSTATICACTUATOR, /** User-defined type.*/ kIfcActuatorTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcActuatorTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcActuatorTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcActuatorTypeEnum& getUnset() { static OdIfc2x3::IfcActuatorTypeEnum nullEnum = OdIfc2x3::kIfcActuatorTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcAddressTypeEnum& getUnset() { static OdIfc2x3::IfcAddressTypeEnum nullEnum = OdIfc2x3::kIfcAddressTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcAheadOrBehind& getUnset() { static OdIfc2x3::IfcAheadOrBehind nullEnum = OdIfc2x3::kIfcAheadOrBehind_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration identifies different types of air terminal boxes. */ enum IfcAirTerminalBoxTypeEnum { /** Terminal box does not include a means to reset the volume automatically to an outside signal such as thermostat.*/ kIfcAirTerminalBoxTypeEnum_CONSTANTFLOW, /** Terminal box includes a means to reset the volume automatically to a different control point in response to an outside signal such as thermostat: air-flow rate depends on supply pressure.*/ kIfcAirTerminalBoxTypeEnum_VARIABLEFLOWPRESSUREDEPENDANT, /** Terminal box includes a means to reset the volume automatically to a different control point in response to an outside signal such as thermostat: air-flow rate is independent of supply pressure.*/ kIfcAirTerminalBoxTypeEnum_VARIABLEFLOWPRESSUREINDEPENDANT, /** User-defined terminal box.*/ kIfcAirTerminalBoxTypeEnum_USERDEFINED, /** Undefined terminal box.*/ kIfcAirTerminalBoxTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcAirTerminalBoxTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcAirTerminalBoxTypeEnum& getUnset() { static OdIfc2x3::IfcAirTerminalBoxTypeEnum nullEnum = OdIfc2x3::kIfcAirTerminalBoxTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details Enumeration defining the functional types of air terminals. */ enum IfcAirTerminalTypeEnum { /** A covering for any area through which air passes.*/ kIfcAirTerminalTypeEnum_GRILLE, /** A grille typically equipped with a damper or control valve.*/ kIfcAirTerminalTypeEnum_REGISTER, /** An outlet discharging supply air in various directions and planes.*/ kIfcAirTerminalTypeEnum_DIFFUSER, /** A small, circular diffuser.*/ kIfcAirTerminalTypeEnum_EYEBALL, kIfcAirTerminalTypeEnum_IRIS, kIfcAirTerminalTypeEnum_LINEARGRILLE, kIfcAirTerminalTypeEnum_LINEARDIFFUSER, /** User-defined air terminal type.*/ kIfcAirTerminalTypeEnum_USERDEFINED, /** Undefined air terminal type.*/ kIfcAirTerminalTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcAirTerminalTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcAirTerminalTypeEnum& getUnset() { static OdIfc2x3::IfcAirTerminalTypeEnum nullEnum = OdIfc2x3::kIfcAirTerminalTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details Defines general types of air-to-air heat recovery devices. */ enum IfcAirToAirHeatRecoveryTypeEnum { /** Heat exchanger with moving parts and alternate layers of plates, separated and sealed from the exhaust and supply air stream passages with primary air entering at secondary air outlet location and exiting at secondary air inlet location.*/ kIfcAirToAirHeatRecoveryTypeEnum_FIXEDPLATECOUNTERFLOWEXCHANGER, /** Heat exchanger with moving parts and alternate layers of plates, separated and sealed from the exhaust and supply air stream passages with secondary air flow in the direction perpendicular to primary air flow.*/ kIfcAirToAirHeatRecoveryTypeEnum_FIXEDPLATECROSSFLOWEXCHANGER, /** Heat exchanger with moving parts and alternate layers of plates, separated and sealed from the exhaust and supply air stream passages with primary air entering at secondary air inlet location and exiting at secondary air outlet location.*/ kIfcAirToAirHeatRecoveryTypeEnum_FIXEDPLATEPARALLELFLOWEXCHANGER, /** A heat wheel with a revolving cylinder filled with an air-permeable medium having a large internal surface area.*/ kIfcAirToAirHeatRecoveryTypeEnum_ROTARYWHEEL, /** A typical coil energy recovery loop places extended surface, finned tube water coils in the supply and exhaust airstreams of a building.*/ kIfcAirToAirHeatRecoveryTypeEnum_RUNAROUNDCOILLOOP, /** A passive energy recovery device with a heat pipe divided into evaporator and condenser sections.*/ kIfcAirToAirHeatRecoveryTypeEnum_HEATPIPE, /** An air-to-liquid, liquid-to-air enthalpy recovery system with a sorbent liquid circulates continuously between supply and exhaust airstreams, alternately contacting both airstreams directly in contactor towers.*/ kIfcAirToAirHeatRecoveryTypeEnum_TWINTOWERENTHALPYRECOVERYLOOPS, /** Sealed systems that consist of an evaporator, a condenser, interconnecting piping, and an intermediate working fluid that is present in both liquid and vapor phases where the evaporator and the condenser are usually at opposite ends of a bundle of straight, individual thermosiphon tubes and the exhaust and supply ducts are adjacent to each other.*/ kIfcAirToAirHeatRecoveryTypeEnum_THERMOSIPHONSEALEDTUBEHEATEXCHANGERS, /** Sealed systems that consist of an evaporator, a condenser, interconnecting piping, and an intermediate working fluid that is present in both liquid and vapor phases where the evaporator and condensor coils are installed independently in the ducts and are interconnected by the working fluid piping.*/ kIfcAirToAirHeatRecoveryTypeEnum_THERMOSIPHONCOILTYPEHEATEXCHANGERS, /** User-defined air to air heat recovery type.*/ kIfcAirToAirHeatRecoveryTypeEnum_USERDEFINED, /** Undefined air to air heat recovery type.*/ kIfcAirToAirHeatRecoveryTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcAirToAirHeatRecoveryTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcAirToAirHeatRecoveryTypeEnum& getUnset() { static OdIfc2x3::IfcAirToAirHeatRecoveryTypeEnum nullEnum = OdIfc2x3::kIfcAirToAirHeatRecoveryTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcAlarmTypeEnum defines the range of different types of alarm that can be specified. */ enum IfcAlarmTypeEnum { /** An audible alarm.*/ kIfcAlarmTypeEnum_BELL, /** An alarm activation mechanism in which a protective glass has to be broken to enable a button to be pressed.*/ kIfcAlarmTypeEnum_BREAKGLASSBUTTON, /** A visual alarm.*/ kIfcAlarmTypeEnum_LIGHT, /** An alarm activation mechanism in which activation is achieved by a pulling action.*/ kIfcAlarmTypeEnum_MANUALPULLBOX, /** An audible alarm.*/ kIfcAlarmTypeEnum_SIREN, /** An audible alarm.*/ kIfcAlarmTypeEnum_WHISTLE, /** User-defined type.*/ kIfcAlarmTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcAlarmTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcAlarmTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcAlarmTypeEnum& getUnset() { static OdIfc2x3::IfcAlarmTypeEnum nullEnum = OdIfc2x3::kIfcAlarmTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This type definition is used to distinguish between different types of structural analysis models. The analysis models are differentiated by their dimensionality. */ enum IfcAnalysisModelTypeEnum { /** In plan loading 2D*/ kIfcAnalysisModelTypeEnum_IN_PLANE_LOADING_2D, /** Out plane loading 2D*/ kIfcAnalysisModelTypeEnum_OUT_PLANE_LOADING_2D, /** Loading 3D*/ kIfcAnalysisModelTypeEnum_LOADING_3D, /** User defined*/ kIfcAnalysisModelTypeEnum_USERDEFINED, /** Not defined*/ kIfcAnalysisModelTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcAnalysisModelTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcAnalysisModelTypeEnum& getUnset() { static OdIfc2x3::IfcAnalysisModelTypeEnum nullEnum = OdIfc2x3::kIfcAnalysisModelTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration is used to distinguish between different types of structural analysis methods, including first order theory, second order theory (small deformations), third order theory (large deformations) and the full nonlinear theory (geometric nonlinearity together with other nonlinearities such as plasticity). */ enum IfcAnalysisTheoryTypeEnum { /** 1st order theory*/ kIfcAnalysisTheoryTypeEnum_FIRST_ORDER_THEORY, /** 2nd order theory*/ kIfcAnalysisTheoryTypeEnum_SECOND_ORDER_THEORY, /** 3rd order theory*/ kIfcAnalysisTheoryTypeEnum_THIRD_ORDER_THEORY, /** Full non-linear theory*/ kIfcAnalysisTheoryTypeEnum_FULL_NONLINEAR_THEORY, /** User defined.*/ kIfcAnalysisTheoryTypeEnum_USERDEFINED, /** Undefined.*/ kIfcAnalysisTheoryTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcAnalysisTheoryTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcAnalysisTheoryTypeEnum& getUnset() { static OdIfc2x3::IfcAnalysisTheoryTypeEnum nullEnum = OdIfc2x3::kIfcAnalysisTheoryTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details IfcArithmeticOperatorEnum specifies the form of arithmetic operation implied by the relationship. */ enum IfcArithmeticOperatorEnum { /** Add*/ kIfcArithmeticOperatorEnum_ADD, /** Divide*/ kIfcArithmeticOperatorEnum_DIVIDE, /** Multiply*/ kIfcArithmeticOperatorEnum_MULTIPLY, /** Subtract*/ kIfcArithmeticOperatorEnum_SUBTRACT, /** The value is unset.*/ kIfcArithmeticOperatorEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcArithmeticOperatorEnum& getUnset() { static OdIfc2x3::IfcArithmeticOperatorEnum nullEnum = OdIfc2x3::kIfcArithmeticOperatorEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration defines where the assembly is intended to take place, either in a factory or on the building site. */ enum IfcAssemblyPlaceEnum { /** This assembly is assembled at site.*/ kIfcAssemblyPlaceEnum_SITE, /** This assembly is assembled in a factory.*/ kIfcAssemblyPlaceEnum_FACTORY, /** No description available.*/ kIfcAssemblyPlaceEnum_NOTDEFINED, /** The value is unset.*/ kIfcAssemblyPlaceEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcAssemblyPlaceEnum& getUnset() { static OdIfc2x3::IfcAssemblyPlaceEnum nullEnum = OdIfc2x3::kIfcAssemblyPlaceEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcBSplineCurveForm represents a part of a curve of some specific form. */ enum IfcBSplineCurveForm { /** A connected sequence of line segments represented by degree 1 B-spline basis functions.*/ kIfcBSplineCurveForm_POLYLINE_FORM, /** An arc of a circle, or a complete circle represented by a B-spline curve.*/ kIfcBSplineCurveForm_CIRCULAR_ARC, /** An arc of an ellipse, or a complete ellipse, represented by a B-spline curve.*/ kIfcBSplineCurveForm_ELLIPTIC_ARC, /** An arc of finite length of a parabola represented by a B-spline curve.*/ kIfcBSplineCurveForm_PARABOLIC_ARC, /** An arc of finite length of one branch of a hyperbola represented by a B-spline curve.*/ kIfcBSplineCurveForm_HYPERBOLIC_ARC, /** A B-spline curve for which no particular form is specified.*/ kIfcBSplineCurveForm_UNSPECIFIED, /** The value is unset.*/ kIfcBSplineCurveForm_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcBSplineCurveForm& getUnset() { static OdIfc2x3::IfcBSplineCurveForm nullEnum = OdIfc2x3::kIfcBSplineCurveForm_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration defines the different predefined types of beams that can further specify an IfcBeam or IfcBeamType. */ enum IfcBeamTypeEnum { /** A standard beam usually used horizontally.*/ kIfcBeamTypeEnum_BEAM, /** A beam used to support a floor or ceiling.*/ kIfcBeamTypeEnum_JOIST, /** A beam or horizontal piece of material over an opening (e.g. door, window).*/ kIfcBeamTypeEnum_LINTEL, /** A beam that forms part of a slab construction and acts together with the slab which it carries. Such beams are often of T-shape (therefore the English name), but may have other shapes as well, e.g. an L-Shape or an Inverted-T-Shape.*/ kIfcBeamTypeEnum_T_BEAM, /** User-defined linear beam element.*/ kIfcBeamTypeEnum_USERDEFINED, /** Undefined linear beam element.*/ kIfcBeamTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcBeamTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcBeamTypeEnum& getUnset() { static OdIfc2x3::IfcBeamTypeEnum nullEnum = OdIfc2x3::kIfcBeamTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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, /** The value is unset.*/ kIfcBenchmarkEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcBenchmarkEnum& getUnset() { static OdIfc2x3::IfcBenchmarkEnum nullEnum = OdIfc2x3::kIfcBenchmarkEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details Enumeration defining the typical types of boilers. */ enum IfcBoilerTypeEnum { /** Water boiler.*/ kIfcBoilerTypeEnum_WATER, /** Steam boiler.*/ kIfcBoilerTypeEnum_STEAM, /** User-defined Boiler type.*/ kIfcBoilerTypeEnum_USERDEFINED, /** Undefined Boiler type.*/ kIfcBoilerTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcBoilerTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcBoilerTypeEnum& getUnset() { static OdIfc2x3::IfcBoilerTypeEnum nullEnum = OdIfc2x3::kIfcBoilerTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcBooleanOperator& getUnset() { static OdIfc2x3::IfcBooleanOperator nullEnum = OdIfc2x3::kIfcBooleanOperator_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration defines the available generic types for IfcBuildingElementProxy or IfcBuildingElementProxyType. */ enum IfcBuildingElementProxyTypeEnum { /** User-defined building element proxy.*/ kIfcBuildingElementProxyTypeEnum_USERDEFINED, /** Undefined building element proxy.*/ kIfcBuildingElementProxyTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcBuildingElementProxyTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcBuildingElementProxyTypeEnum& getUnset() { static OdIfc2x3::IfcBuildingElementProxyTypeEnum nullEnum = OdIfc2x3::kIfcBuildingElementProxyTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcCableCarrierFittingTypeEnum defines the range of different types of cable carrier fitting that can be specified. */ enum IfcCableCarrierFittingTypeEnum { /** A fitting that changes the route of the cable carrier.*/ kIfcCableCarrierFittingTypeEnum_BEND, /** A fitting at which two branches are taken from the main route of the cable carrier simultaneously.*/ kIfcCableCarrierFittingTypeEnum_CROSS, /** A fitting that changes the physical size of the main route of the cable carrier.*/ kIfcCableCarrierFittingTypeEnum_REDUCER, /** A fitting at which a branch is taken from the main route of the cable carrier.*/ kIfcCableCarrierFittingTypeEnum_TEE, /** User-defined type.*/ kIfcCableCarrierFittingTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcCableCarrierFittingTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcCableCarrierFittingTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcCableCarrierFittingTypeEnum& getUnset() { static OdIfc2x3::IfcCableCarrierFittingTypeEnum nullEnum = OdIfc2x3::kIfcCableCarrierFittingTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcCableCarrierSegmentTypeEnum defines the range of different types of cable carrier segment that can be specified. */ enum IfcCableCarrierSegmentTypeEnum { /** An open carrier segment on which cables are carried on a ladder structure.*/ kIfcCableCarrierSegmentTypeEnum_CABLELADDERSEGMENT, /** A (typically) open carrier segment onto which cables are laid.*/ kIfcCableCarrierSegmentTypeEnum_CABLETRAYSEGMENT, /** An enclosed carrier segment with one or more compartments into which cables are placed.*/ kIfcCableCarrierSegmentTypeEnum_CABLETRUNKINGSEGMENT, /** An enclosed tubular carrier segment through which cables are pulled.*/ kIfcCableCarrierSegmentTypeEnum_CONDUITSEGMENT, /** User-defined type.*/ kIfcCableCarrierSegmentTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcCableCarrierSegmentTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcCableCarrierSegmentTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcCableCarrierSegmentTypeEnum& getUnset() { static OdIfc2x3::IfcCableCarrierSegmentTypeEnum nullEnum = OdIfc2x3::kIfcCableCarrierSegmentTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcCableSegmentTypeEnum defines the range of different types of cable segment that can be specified. */ enum IfcCableSegmentTypeEnum { /** Cable with a specific purpose to lead electric current within a circuit or any other electric construction. Includes all types of electric cables, mainly several core segments or conductor segments wrapped together.*/ kIfcCableSegmentTypeEnum_CABLESEGMENT, /** A single linear element within a cable or an exposed wire (such as for grounding) with the specific purpose to lead electric current, data, or a telecommunications signal.*/ kIfcCableSegmentTypeEnum_CONDUCTORSEGMENT, /** User-defined type.*/ kIfcCableSegmentTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcCableSegmentTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcCableSegmentTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcCableSegmentTypeEnum& getUnset() { static OdIfc2x3::IfcCableSegmentTypeEnum nullEnum = OdIfc2x3::kIfcCableSegmentTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcChangeActionEnum& getUnset() { static OdIfc2x3::IfcChangeActionEnum nullEnum = OdIfc2x3::kIfcChangeActionEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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, /** User-defined chiller type.*/ kIfcChillerTypeEnum_USERDEFINED, /** Undefined chiller type.*/ kIfcChillerTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcChillerTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcChillerTypeEnum& getUnset() { static OdIfc2x3::IfcChillerTypeEnum nullEnum = OdIfc2x3::kIfcChillerTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details Enumeration defining the typical types of coils. */ enum IfcCoilTypeEnum { /** Cooling coil using a refrigerant to cool the air stream directly.*/ kIfcCoilTypeEnum_DXCOOLINGCOIL, /** Cooling coil using chilled water. HYDRONICCOIL supercedes this enumerator.*/ kIfcCoilTypeEnum_WATERCOOLINGCOIL, /** Heating coil using steam as heating source.*/ kIfcCoilTypeEnum_STEAMHEATINGCOIL, /** Heating coil using hot water as a heating source. HYDRONICCOIL supercedes this enumerator.*/ kIfcCoilTypeEnum_WATERHEATINGCOIL, /** Heating coil using electricity as a heating source.*/ kIfcCoilTypeEnum_ELECTRICHEATINGCOIL, /** Heating coil using gas as a heating source.*/ kIfcCoilTypeEnum_GASHEATINGCOIL, /** User-defined coil type.*/ kIfcCoilTypeEnum_USERDEFINED, /** Undefined coil type.*/ kIfcCoilTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcCoilTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcCoilTypeEnum& getUnset() { static OdIfc2x3::IfcCoilTypeEnum nullEnum = OdIfc2x3::kIfcCoilTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration defines the different predefined types of columns that can further specify an IfcColumn or IfcColumnType. */ enum IfcColumnTypeEnum { /** A usually vertical member that may be load bearing and requiring resistance to vertical forces by compression but also sometimes to lateral forces.*/ kIfcColumnTypeEnum_COLUMN, /** User-defined linear element.*/ kIfcColumnTypeEnum_USERDEFINED, /** Undefined linear element.*/ kIfcColumnTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcColumnTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcColumnTypeEnum& getUnset() { static OdIfc2x3::IfcColumnTypeEnum nullEnum = OdIfc2x3::kIfcColumnTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details Enumeration defining the typical types of compressors. */ enum IfcCompressorTypeEnum { /** The pressure of refrigerant vapor is increased by a continuous transfer of angular momentum from a rotating member to the vapor followed by conversion of this momentum into static pressure.*/ kIfcCompressorTypeEnum_DYNAMIC, /** Positive-displacement compressor using a piston driven by a connecting rod from a crankshaft.*/ kIfcCompressorTypeEnum_RECIPROCATING, /** Positive-displacement compressor using a roller or rotor device.*/ kIfcCompressorTypeEnum_ROTARY, /** Positive-displacement compressor using two inter-fitting, spiral-shaped scroll members.*/ kIfcCompressorTypeEnum_SCROLL, /** Positive-displacement compressor using a rolling motion of one circle outside or inside the circumference of a basic circle and produce either epitrochoids or hypotrochoids.*/ kIfcCompressorTypeEnum_TROCHOIDAL, /** Positive-displacement reciprocating compressor where vapor is compressed in a single stage.*/ kIfcCompressorTypeEnum_SINGLESTAGE, /** Positive-displacement reciprocating compressor where pressure is increased by a booster.*/ kIfcCompressorTypeEnum_BOOSTER, /** Positive-displacement reciprocating compressor where the shaft extends through a seal in the crankcase for an external drive.*/ kIfcCompressorTypeEnum_OPENTYPE, /** 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 reciprocating compressor where the hermetic compressors use bolted construction amenable to field repair.*/ kIfcCompressorTypeEnum_SEMIHERMETIC, /** Positive-displacement reciprocating compressor where the motor compressor is mounted inside a steel shell, which, in turn is sealed by welding.*/ kIfcCompressorTypeEnum_WELDEDSHELLHERMETIC, /** Positive-displacement rotary compressor using a roller mounted on the eccentric of a shaft with a single vane in the nonrotating cylindrical housing.*/ kIfcCompressorTypeEnum_ROLLINGPISTON, /** Positive-displacement rotary compressor using a roller mounted on the eccentric of a shaft with multiple vanes in the nontotating cylindrical housing.*/ kIfcCompressorTypeEnum_ROTARYVANE, /** Positive-displacement rotary compressor using a single cylindrical main rotor that works with a pair of gate rotors.*/ kIfcCompressorTypeEnum_SINGLESCREW, /** Positive-displacement rotary compressor using two mating helically grooved rotors, male (lobes) and female (flutes) in a stationary housing with inlet and outlet gas ports.*/ kIfcCompressorTypeEnum_TWINSCREW, /** User-defined compressor type.*/ kIfcCompressorTypeEnum_USERDEFINED, /** Undefined compressor type.*/ kIfcCompressorTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcCompressorTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcCompressorTypeEnum& getUnset() { static OdIfc2x3::IfcCompressorTypeEnum nullEnum = OdIfc2x3::kIfcCompressorTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details Enumeration defining the typical types of condensers. Air is used as the cooling medium for AIRCOOLED; water is used as the cooling medium for all other types. */ enum IfcCondenserTypeEnum { /** Water-cooled condenser with cooling water circulated through one or more tubes contained within the shell.*/ kIfcCondenserTypeEnum_WATERCOOLEDSHELLTUBE, /** Water-cooled condenser with cooling water circulated through one or more continuous or assembled coils contained within the shell.*/ kIfcCondenserTypeEnum_WATERCOOLEDSHELLCOIL, /** Water-cooled condenser consisting of one or more assemblies of two tubes, one within the other.*/ kIfcCondenserTypeEnum_WATERCOOLEDTUBEINTUBE, /** Water-cooled condenser with plates brazed together to form an assembly of separate channels.*/ kIfcCondenserTypeEnum_WATERCOOLEDBRAZEDPLATE, /** A condenser in which heat is transferred to an air-stream.*/ kIfcCondenserTypeEnum_AIRCOOLED, /** A condenser that is cooled evaporatively.*/ kIfcCondenserTypeEnum_EVAPORATIVECOOLED, /** User-defined condenser type.*/ kIfcCondenserTypeEnum_USERDEFINED, /** Undefined condenser type.*/ kIfcCondenserTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcCondenserTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcCondenserTypeEnum& getUnset() { static OdIfc2x3::IfcCondenserTypeEnum nullEnum = OdIfc2x3::kIfcCondenserTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcConnectionTypeEnum& getUnset() { static OdIfc2x3::IfcConnectionTypeEnum nullEnum = OdIfc2x3::kIfcConnectionTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcConstraintEnum& getUnset() { static OdIfc2x3::IfcConstraintEnum nullEnum = OdIfc2x3::kIfcConstraintEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcControllerTypeEnum defines the range of different types of controller that can be specified. */ enum IfcControllerTypeEnum { /** Output increases or decreases at a constant or accelerating rate.*/ kIfcControllerTypeEnum_FLOATING, /** Output is proportional to the control error and optionally time integral and derivative.*/ kIfcControllerTypeEnum_PROPORTIONAL, kIfcControllerTypeEnum_PROPORTIONALINTEGRAL, kIfcControllerTypeEnum_PROPORTIONALINTEGRALDERIVATIVE, kIfcControllerTypeEnum_TIMEDTWOPOSITION, /** Output can be either on or off.*/ kIfcControllerTypeEnum_TWOPOSITION, /** User-defined type.*/ kIfcControllerTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcControllerTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcControllerTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcControllerTypeEnum& getUnset() { static OdIfc2x3::IfcControllerTypeEnum nullEnum = OdIfc2x3::kIfcControllerTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details There are two general types of cooled or chilled beams: passive and active. An active Cooled Beam uses a fan or other auxiliary device to aid in air recirculation, while a passive Cooled Beam relies solely on convection to cool the space. */ enum IfcCooledBeamTypeEnum { /** An active or ventilated cooled beam provides cooling (and heating) but can also function as an air terminal in a ventilation system.*/ kIfcCooledBeamTypeEnum_ACTIVE, /** A passive or static cooled beam provides cooling (and heating) to a room or zone.*/ kIfcCooledBeamTypeEnum_PASSIVE, /** User-defined cooled beam type.*/ kIfcCooledBeamTypeEnum_USERDEFINED, /** Undefined cooled beam type.*/ kIfcCooledBeamTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcCooledBeamTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcCooledBeamTypeEnum& getUnset() { static OdIfc2x3::IfcCooledBeamTypeEnum nullEnum = OdIfc2x3::kIfcCooledBeamTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details Enumeration defining the typical types of cooling towers. */ enum IfcCoolingTowerTypeEnum { /** Air flow is produced naturally.*/ kIfcCoolingTowerTypeEnum_NATURALDRAFT, /** Air flow is produced by a mechanical device, typically one or more fans, located on the air outlet side of the cooling tower.*/ kIfcCoolingTowerTypeEnum_MECHANICALINDUCEDDRAFT, /** Air flow is produced by a mechanical device, typically one or more fans, located on the inlet air side of the cooling tower.*/ kIfcCoolingTowerTypeEnum_MECHANICALFORCEDDRAFT, /** User-defined cooling tower type.*/ kIfcCoolingTowerTypeEnum_USERDEFINED, /** Undefined cooling tower type.*/ kIfcCoolingTowerTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcCoolingTowerTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcCoolingTowerTypeEnum& getUnset() { static OdIfc2x3::IfcCoolingTowerTypeEnum nullEnum = OdIfc2x3::kIfcCoolingTowerTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details An IfcCostScheduleTypeEnum is a list of the available types of cost schedule from which that required may be selected. */ enum IfcCostScheduleTypeEnum { /** An allocation of money for a particular purpose.*/ kIfcCostScheduleTypeEnum_BUDGET, /** An assessment of the amount of money needing to be expended for a defined purpose based on incomplete information about the goods and services required for a construction or installation.*/ kIfcCostScheduleTypeEnum_COSTPLAN, /** An assessment of the amount of money needing to be expended for a defined purpose based on actual information about the goods and services required for a construction or installation.*/ kIfcCostScheduleTypeEnum_ESTIMATE, /** An offer to provide goods and services.*/ kIfcCostScheduleTypeEnum_TENDER, /** A complete listing of all work items forming construction or installation works in which costs have been allocated to work items.*/ kIfcCostScheduleTypeEnum_PRICEDBILLOFQUANTITIES, /** A complete listing of all work items forming construction or installation works in which costs have not yet been allocated to work items.*/ kIfcCostScheduleTypeEnum_UNPRICEDBILLOFQUANTITIES, /** A listing of each type of goods forming construction or installation works with the cost of purchase, construction/installation, overheads and profit assigned so that additional items of that type can be costed.*/ kIfcCostScheduleTypeEnum_SCHEDULEOFRATES, /** User-defined type.*/ kIfcCostScheduleTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcCostScheduleTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcCostScheduleTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcCostScheduleTypeEnum& getUnset() { static OdIfc2x3::IfcCostScheduleTypeEnum nullEnum = OdIfc2x3::kIfcCostScheduleTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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, /** The covering is used to insulate an element for thermal or acoustic purposes.*/ kIfcCoveringTypeEnum_INSULATION, /** An impervious layer that could be used for e.g. roof covering (below tiling - that may be known as sarking etc.) or as a damp proof course membrane; also, waterproofing material on a bridge structure (typically on top of bridge slab).*/ kIfcCoveringTypeEnum_MEMBRANE, /** The covering is used to isolate a distribution element from a space in which it is contained.*/ kIfcCoveringTypeEnum_SLEEVING, /** The covering is used for wrapping particularly of distribution elements using tape.*/ kIfcCoveringTypeEnum_WRAPPING, /** 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 OdIfc2x3::IfcCoveringTypeEnum& getUnset() { static OdIfc2x3::IfcCoveringTypeEnum nullEnum = OdIfc2x3::kIfcCoveringTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcCurrencyEnum& getUnset() { static OdIfc2x3::IfcCurrencyEnum nullEnum = OdIfc2x3::kIfcCurrencyEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration defines the valid types of curtain wall that can be predefined using the enumeration values. */ enum IfcCurtainWallTypeEnum { /** No description available.*/ kIfcCurtainWallTypeEnum_USERDEFINED, /** No description available.*/ kIfcCurtainWallTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcCurtainWallTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcCurtainWallTypeEnum& getUnset() { static OdIfc2x3::IfcCurtainWallTypeEnum nullEnum = OdIfc2x3::kIfcCurtainWallTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration defines the various types of damper */ enum IfcDamperTypeEnum { /** 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, /** 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, /** Relief damper used to allow air to move upon a buildup of a specified pressure differential. Commonly operated by mechanical spring.*/ kIfcDamperTypeEnum_RELIEFDAMPER, /** Blast damper used to prevent protect occupants and equipment against overpressures resultant of an explosion. Commonly operated by mechanical spring.*/ kIfcDamperTypeEnum_BLASTDAMPER, /** Gravity damper closes from the force of gravity. Commonly operated by gravitational weight.*/ kIfcDamperTypeEnum_GRAVITYDAMPER, /** Gravity-relief damper used to allow air to move upon a buildup of enough pressure to overcome the gravitational force exerted upon the damper blades. Commonly operated by gravitational weight.*/ kIfcDamperTypeEnum_GRAVITYRELIEFDAMPER, /** Backdraft damper used to restrict the movement of air in one direction. Commonly operated by mechanical spring.*/ kIfcDamperTypeEnum_BALANCINGDAMPER, /** Fume hood exhaust damper. Commonly operated by actuator.*/ kIfcDamperTypeEnum_FUMEHOODEXHAUST, /** User-defined damper.*/ kIfcDamperTypeEnum_USERDEFINED, /** Undefined damper.*/ kIfcDamperTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcDamperTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcDamperTypeEnum& getUnset() { static OdIfc2x3::IfcDamperTypeEnum nullEnum = OdIfc2x3::kIfcDamperTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details IfcDataOriginEnum identifies the origin of time data. */ enum IfcDataOriginEnum { /** The origin of the time data is a measurement device.*/ kIfcDataOriginEnum_MEASURED, /** The time data are a prediction.*/ kIfcDataOriginEnum_PREDICTED, /** The origin of the time data is a simulation.*/ kIfcDataOriginEnum_SIMULATED, /** User defined.*/ kIfcDataOriginEnum_USERDEFINED, /** The origin of the time data is undefined.*/ kIfcDataOriginEnum_NOTDEFINED, /** The value is unset.*/ kIfcDataOriginEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcDataOriginEnum& getUnset() { static OdIfc2x3::IfcDataOriginEnum nullEnum = OdIfc2x3::kIfcDataOriginEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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, /** Moment of inertia unit*/ kIfcDerivedUnitEnum_MOMENTOFINERTIAUNIT, /** 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, /** Curvature unit*/ kIfcDerivedUnitEnum_CURVATUREUNIT, /** Heating value unit*/ kIfcDerivedUnitEnum_HEATINGVALUEUNIT, /** Ion concentration unit*/ kIfcDerivedUnitEnum_IONCONCENTRATIONUNIT, /** Luminous intensity distribution unit*/ kIfcDerivedUnitEnum_LUMINOUSINTENSITYDISTRIBUTIONUNIT, /** Mass per length unit*/ kIfcDerivedUnitEnum_MASSPERLENGTHUNIT, /** Modulus of linear subgrade reaction unit*/ kIfcDerivedUnitEnum_MODULUSOFLINEARSUBGRADEREACTIONUNIT, /** Modulus of rotational subgrade reaction unit*/ kIfcDerivedUnitEnum_MODULUSOFROTATIONALSUBGRADEREACTIONUNIT, /** PH Unit*/ kIfcDerivedUnitEnum_PHUNIT, /** Rotational mass unit*/ kIfcDerivedUnitEnum_ROTATIONALMASSUNIT, /** Section area integral unit*/ kIfcDerivedUnitEnum_SECTIONAREAINTEGRALUNIT, /** Section modulus unit*/ kIfcDerivedUnitEnum_SECTIONMODULUSUNIT, /** Sound power unit*/ kIfcDerivedUnitEnum_SOUNDPOWERUNIT, /** Sound pressure unit*/ kIfcDerivedUnitEnum_SOUNDPRESSUREUNIT, /** Temperature gradient unit*/ kIfcDerivedUnitEnum_TEMPERATUREGRADIENTUNIT, /** Thermal expansion coefficient unit*/ kIfcDerivedUnitEnum_THERMALEXPANSIONCOEFFICIENTUNIT, /** Warping constraint unit*/ kIfcDerivedUnitEnum_WARPINGCONSTANTUNIT, /** Warping moment unit*/ kIfcDerivedUnitEnum_WARPINGMOMENTUNIT, /** User defined derived unit.*/ kIfcDerivedUnitEnum_USERDEFINED, /** The value is unset.*/ kIfcDerivedUnitEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcDerivedUnitEnum& getUnset() { static OdIfc2x3::IfcDerivedUnitEnum nullEnum = OdIfc2x3::kIfcDerivedUnitEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The dimension extent usage declares the usage of a dimension terminator symbol, being either an origin, or a target. */ enum IfcDimensionExtentUsage { /** ORIGIN*/ kIfcDimensionExtentUsage_ORIGIN, /** TARGET*/ kIfcDimensionExtentUsage_TARGET, /** The value is unset.*/ kIfcDimensionExtentUsage_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcDimensionExtentUsage& getUnset() { static OdIfc2x3::IfcDimensionExtentUsage nullEnum = OdIfc2x3::kIfcDimensionExtentUsage_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcDirectionSenseEnum& getUnset() { static OdIfc2x3::IfcDirectionSenseEnum nullEnum = OdIfc2x3::kIfcDirectionSenseEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration identifies different types of distribution chambers. */ enum IfcDistributionChamberElementTypeEnum { /** Space formed in the ground for the passage of pipes, cables, ducts.*/ kIfcDistributionChamberElementTypeEnum_FORMEDDUCT, /** Chamber constructed on a drain, sewer or pipeline with a removable cover that permits visible inspection.*/ kIfcDistributionChamberElementTypeEnum_INSPECTIONCHAMBER, /** Recess or chamber formed to permit access for inspection of substructure and services.*/ kIfcDistributionChamberElementTypeEnum_INSPECTIONPIT, /** Chamber constructed on a drain, sewer or pipeline with a removable cover that permits the entry of a person.*/ kIfcDistributionChamberElementTypeEnum_MANHOLE, /** Chamber that houses a meter(s).*/ kIfcDistributionChamberElementTypeEnum_METERCHAMBER, /** Recessed or small chamber into which liquid is drained to facilitate its collection for removal.*/ kIfcDistributionChamberElementTypeEnum_SUMP, /** Excavated chamber, the length of which typically exceeds the width.*/ kIfcDistributionChamberElementTypeEnum_TRENCH, /** Chamber that houses a valve(s).*/ kIfcDistributionChamberElementTypeEnum_VALVECHAMBER, /** User-defined chamber type.*/ kIfcDistributionChamberElementTypeEnum_USERDEFINED, /** Undefined chamber type.*/ kIfcDistributionChamberElementTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcDistributionChamberElementTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcDistributionChamberElementTypeEnum& getUnset() { static OdIfc2x3::IfcDistributionChamberElementTypeEnum nullEnum = OdIfc2x3::kIfcDistributionChamberElementTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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, /** User defined.*/ kIfcDocumentConfidentialityEnum_USERDEFINED, /** Not defined.*/ kIfcDocumentConfidentialityEnum_NOTDEFINED, /** The value is unset.*/ kIfcDocumentConfidentialityEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcDocumentConfidentialityEnum& getUnset() { static OdIfc2x3::IfcDocumentConfidentialityEnum nullEnum = OdIfc2x3::kIfcDocumentConfidentialityEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcDocumentStatusEnum& getUnset() { static OdIfc2x3::IfcDocumentStatusEnum nullEnum = OdIfc2x3::kIfcDocumentStatusEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcDoorPanelOperationEnum& getUnset() { static OdIfc2x3::IfcDoorPanelOperationEnum nullEnum = OdIfc2x3::kIfcDoorPanelOperationEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcDoorPanelPositionEnum& getUnset() { static OdIfc2x3::IfcDoorPanelPositionEnum nullEnum = OdIfc2x3::kIfcDoorPanelPositionEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcDoorStyleConstructionEnum& getUnset() { static OdIfc2x3::IfcDoorStyleConstructionEnum nullEnum = OdIfc2x3::kIfcDoorStyleConstructionEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcDoorStyleOperationEnum& getUnset() { static OdIfc2x3::IfcDoorStyleOperationEnum nullEnum = OdIfc2x3::kIfcDoorStyleOperationEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration is used to identify the primary purpose of a duct fitting. This is a very basic categorization mechanism to generically identify the duct fitting type. Subcategories of duct fittings are not enumerated. */ enum IfcDuctFittingTypeEnum { /** A fitting with typically two ports used to change the direction of flow between connected elements.*/ kIfcDuctFittingTypeEnum_BEND, /** Connector fitting, typically used to join two ports together within a flow distribution system (e.g., a coupling used to join two duct segments).*/ kIfcDuctFittingTypeEnum_CONNECTOR, /** 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).*/ kIfcDuctFittingTypeEnum_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).*/ kIfcDuctFittingTypeEnum_EXIT, /** 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.).*/ kIfcDuctFittingTypeEnum_JUNCTION, /** A fitting with typically two ports used to obstruct or restrict flow between the connected elements (e.g., screen, perforated plate, etc.).*/ kIfcDuctFittingTypeEnum_OBSTRUCTION, /** A fitting with typically two ports having different shapes or sizes. Can also be used to change the direction of flow between connected elements.*/ kIfcDuctFittingTypeEnum_TRANSITION, /** User-defined fitting.*/ kIfcDuctFittingTypeEnum_USERDEFINED, /** Undefined fitting.*/ kIfcDuctFittingTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcDuctFittingTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcDuctFittingTypeEnum& getUnset() { static OdIfc2x3::IfcDuctFittingTypeEnum nullEnum = OdIfc2x3::kIfcDuctFittingTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration is used to identify the primary purpose of a duct segment. This is a very basic categorization mechanism to generically identify the duct segment type. Subcategories of duct segments are not enumerated. */ enum IfcDuctSegmentTypeEnum { /** A rigid segment is a continuous linear segment of duct that cannot be deformed.*/ kIfcDuctSegmentTypeEnum_RIGIDSEGMENT, /** A flexible segment is a continuous non-linear segment of duct that can be deformed and change the direction of flow.*/ kIfcDuctSegmentTypeEnum_FLEXIBLESEGMENT, /** User-defined segment.*/ kIfcDuctSegmentTypeEnum_USERDEFINED, /** Undefined segment.*/ kIfcDuctSegmentTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcDuctSegmentTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcDuctSegmentTypeEnum& getUnset() { static OdIfc2x3::IfcDuctSegmentTypeEnum nullEnum = OdIfc2x3::kIfcDuctSegmentTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details Enumeration defining the typical types of duct silencers. */ enum IfcDuctSilencerTypeEnum { /** Flat-oval shaped duct silencer type.*/ kIfcDuctSilencerTypeEnum_FLATOVAL, /** Rectangular shaped duct silencer type.*/ kIfcDuctSilencerTypeEnum_RECTANGULAR, /** Round duct silencer type.*/ kIfcDuctSilencerTypeEnum_ROUND, /** User-defined duct silencer type.*/ kIfcDuctSilencerTypeEnum_USERDEFINED, /** Undefined duct silencer type.*/ kIfcDuctSilencerTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcDuctSilencerTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcDuctSilencerTypeEnum& getUnset() { static OdIfc2x3::IfcDuctSilencerTypeEnum nullEnum = OdIfc2x3::kIfcDuctSilencerTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcElectricApplianceTypeEnum defines the range of different types of electrical appliance that can be specified. */ enum IfcElectricApplianceTypeEnum { /** A desktop, laptop, PDA or other type of computer that can be moved from one place to another and connected to an electrical supply via a plugged outlet.*/ kIfcElectricApplianceTypeEnum_COMPUTER, kIfcElectricApplianceTypeEnum_DIRECTWATERHEATER, /** An appliance that has the primary function of washing dishes.*/ kIfcElectricApplianceTypeEnum_DISHWASHER, /** An electrical appliance that has the primary function of cooking food (including oven, hob, grill).*/ kIfcElectricApplianceTypeEnum_ELECTRICCOOKER, kIfcElectricApplianceTypeEnum_ELECTRICHEATER, kIfcElectricApplianceTypeEnum_FACSIMILE, /** An electrical appliance that is used occasionally to provide ventilation. A freestanding fan is a 'plugged' appliance whose load may be removed from an electric circuit.*/ kIfcElectricApplianceTypeEnum_FREESTANDINGFAN, /** An electrical appliance that has the primary function of storing food at temperatures below the freezing point of water.*/ kIfcElectricApplianceTypeEnum_FREEZER, /** An electrical appliance that combines the functions of a freezer and a refrigerator through the provision of separate compartments.*/ kIfcElectricApplianceTypeEnum_FRIDGE_FREEZER, /** An electrical appliance that has the primary function of drying hands.*/ kIfcElectricApplianceTypeEnum_HANDDRYER, kIfcElectricApplianceTypeEnum_INDIRECTWATERHEATER, /** An electrical appliance that has the primary function of cooking food using microwaves.*/ kIfcElectricApplianceTypeEnum_MICROWAVE, /** A machine that has the primary function of reproduction of printed matter.*/ kIfcElectricApplianceTypeEnum_PHOTOCOPIER, kIfcElectricApplianceTypeEnum_PRINTER, /** An electrical appliance that has the primary function of storing food at low temperature but above the freezing point of water.*/ kIfcElectricApplianceTypeEnum_REFRIGERATOR, kIfcElectricApplianceTypeEnum_RADIANTHEATER, kIfcElectricApplianceTypeEnum_SCANNER, kIfcElectricApplianceTypeEnum_TELEPHONE, /** An electrical appliance that has the primary function of drying clothes.*/ kIfcElectricApplianceTypeEnum_TUMBLEDRYER, kIfcElectricApplianceTypeEnum_TV, /** An appliance that stores and vends goods including food, drink, tickets, and goods of various types.*/ kIfcElectricApplianceTypeEnum_VENDINGMACHINE, /** An appliance that has the primary function of washing clothes.*/ kIfcElectricApplianceTypeEnum_WASHINGMACHINE, kIfcElectricApplianceTypeEnum_WATERHEATER, kIfcElectricApplianceTypeEnum_WATERCOOLER, /** User-defined type.*/ kIfcElectricApplianceTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcElectricApplianceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcElectricApplianceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcElectricApplianceTypeEnum& getUnset() { static OdIfc2x3::IfcElectricApplianceTypeEnum nullEnum = OdIfc2x3::kIfcElectricApplianceTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcElectricCurrentEnum& getUnset() { static OdIfc2x3::IfcElectricCurrentEnum nullEnum = OdIfc2x3::kIfcElectricCurrentEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcElectricDistributionPointTypeEnum defines the range of different functions that an electric distribution point can fulfil. */ enum IfcElectricDistributionPointFunctionEnum { /** A distribution point at which alarms are annunciated.*/ kIfcElectricDistributionPointFunctionEnum_ALARMPANEL, /** A distribution point on the incoming electrical supply, typically in domestic premises, at which protective devices are located.*/ kIfcElectricDistributionPointFunctionEnum_CONSUMERUNIT, /** A distribution point at which devices that control or monitor the operation of a site, building or part of a building are located.*/ kIfcElectricDistributionPointFunctionEnum_CONTROLPANEL, /** A distribution point at which connections are made for distribution of electrical circuits usually through protective devices.*/ kIfcElectricDistributionPointFunctionEnum_DISTRIBUTIONBOARD, /** A distribution point at which the detection of gas is annunciated.*/ kIfcElectricDistributionPointFunctionEnum_GASDETECTORPANEL, kIfcElectricDistributionPointFunctionEnum_INDICATORPANEL, /** A distribution point at which information that is available elsewhere is repeated or 'mimicked'.*/ kIfcElectricDistributionPointFunctionEnum_MIMICPANEL, /** A distribution point at which starting and control devices for major plant items are located.*/ kIfcElectricDistributionPointFunctionEnum_MOTORCONTROLCENTRE, /** A distribution point at which switching devices are located.*/ kIfcElectricDistributionPointFunctionEnum_SWITCHBOARD, /** User-defined.*/ kIfcElectricDistributionPointFunctionEnum_USERDEFINED, /** Not defined.*/ kIfcElectricDistributionPointFunctionEnum_NOTDEFINED, /** The value is unset.*/ kIfcElectricDistributionPointFunctionEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcElectricDistributionPointFunctionEnum& getUnset() { static OdIfc2x3::IfcElectricDistributionPointFunctionEnum nullEnum = OdIfc2x3::kIfcElectricDistributionPointFunctionEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcElectricFlowStorageDeviceTypeEnum defines different types of electrical flow storage devices. */ enum IfcElectricFlowStorageDeviceTypeEnum { /** A device for storing energy in chemical form so that it can be released as electrical energy.*/ kIfcElectricFlowStorageDeviceTypeEnum_BATTERY, /** A device that stores electrical energy when an external power supply is present using the electrical property of capacitance.*/ kIfcElectricFlowStorageDeviceTypeEnum_CAPACITORBANK, /** A device that constantly injects currents that precisely correspond to the harmonic components drawn by the load.*/ kIfcElectricFlowStorageDeviceTypeEnum_HARMONICFILTER, /** A device that stores electrical energy in a magnetic field using electrical property of inductance.*/ kIfcElectricFlowStorageDeviceTypeEnum_INDUCTORBANK, /** A device that provides a time limited alternative source of power supply in the event of failure of the main supply.*/ kIfcElectricFlowStorageDeviceTypeEnum_UPS, /** User-defined type.*/ kIfcElectricFlowStorageDeviceTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcElectricFlowStorageDeviceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcElectricFlowStorageDeviceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcElectricFlowStorageDeviceTypeEnum& getUnset() { static OdIfc2x3::IfcElectricFlowStorageDeviceTypeEnum nullEnum = OdIfc2x3::kIfcElectricFlowStorageDeviceTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcElectricGeneratorTypeEnum defines different types of electric generators. */ enum IfcElectricGeneratorTypeEnum { /** User-defined type.*/ kIfcElectricGeneratorTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcElectricGeneratorTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcElectricGeneratorTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcElectricGeneratorTypeEnum& getUnset() { static OdIfc2x3::IfcElectricGeneratorTypeEnum nullEnum = OdIfc2x3::kIfcElectricGeneratorTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcElectricHeaterTypeEnum defines the range of types of electric heater available. */ enum IfcElectricHeaterTypeEnum { /** An electrical device that outputs heat as a total quantity from a point or restricted area that can be considered as a point.*/ kIfcElectricHeaterTypeEnum_ELECTRICPOINTHEATER, /** An electrical device that outputs heat uniformly along its path.*/ kIfcElectricHeaterTypeEnum_ELECTRICCABLEHEATER, /** An electrical device that outputs heat uniformly across its surface area.*/ kIfcElectricHeaterTypeEnum_ELECTRICMATHEATER, /** User-defined.*/ kIfcElectricHeaterTypeEnum_USERDEFINED, /** Not defined.*/ kIfcElectricHeaterTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcElectricHeaterTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcElectricHeaterTypeEnum& getUnset() { static OdIfc2x3::IfcElectricHeaterTypeEnum nullEnum = OdIfc2x3::kIfcElectricHeaterTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcElectricMotorTypeEnum defines the range of different types of electric motor that can be specified. */ enum IfcElectricMotorTypeEnum { /** A motor using either generated or rectified Direct Current (DC) power.*/ kIfcElectricMotorTypeEnum_DC, /** An alternating current motor in which the primary winding on one member (usually the stator) is connected to the power source and a secondary winding or a squirrel-cage secondary winding on the other member (usually the rotor) carries the induced current. There is no physical electrical connection to the secondary winding, its current is induced.*/ kIfcElectricMotorTypeEnum_INDUCTION, /** A two or three-phase induction motor in which the windings, one for each phase, are evenly divided by the same number of electrical degrees.*/ kIfcElectricMotorTypeEnum_POLYPHASE, /** A synchronous motor with a special rotor design which directly lines the rotor up with the rotating magnetic field of the stator, allowing for no slip under load.*/ kIfcElectricMotorTypeEnum_RELUCTANCESYNCHRONOUS, /** A motor that operates at a constant speed up to full load. The rotor speed is equal to the speed of the rotating magnetic field of the stator; there is no slip.*/ kIfcElectricMotorTypeEnum_SYNCHRONOUS, /** User-defined type.*/ kIfcElectricMotorTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcElectricMotorTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcElectricMotorTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcElectricMotorTypeEnum& getUnset() { static OdIfc2x3::IfcElectricMotorTypeEnum nullEnum = OdIfc2x3::kIfcElectricMotorTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcElectricTimeControlTypeEnum defines different types of electrical time control devices. */ enum IfcElectricTimeControlTypeEnum { /** A control that causes action to occur at set times.*/ kIfcElectricTimeControlTypeEnum_TIMECLOCK, /** A control that causes action to occur following a set duration.*/ kIfcElectricTimeControlTypeEnum_TIMEDELAY, /** Electromagnetically operated contactor for making or breaking a control circuit.*/ kIfcElectricTimeControlTypeEnum_RELAY, /** User-defined type.*/ kIfcElectricTimeControlTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcElectricTimeControlTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcElectricTimeControlTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcElectricTimeControlTypeEnum& getUnset() { static OdIfc2x3::IfcElectricTimeControlTypeEnum nullEnum = OdIfc2x3::kIfcElectricTimeControlTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration defines the basic configuration types for element assemblies. */ enum IfcElementAssemblyTypeEnum { /** Assembled accessories or components.*/ kIfcElementAssemblyTypeEnum_ACCESSORY_ASSEMBLY, /** A curved structure.*/ kIfcElementAssemblyTypeEnum_ARCH, /** Interconnected beams, located in one (typically horizontal) plane.*/ kIfcElementAssemblyTypeEnum_BEAM_GRID, /** A rigid frame with additional bracing members.*/ kIfcElementAssemblyTypeEnum_BRACED_FRAME, /** A beam-like superstructure, such as bridge main girder extending between abutments and piers built up of beams, braces (as Members) etc. - may also be an aggregation of girder segments.*/ kIfcElementAssemblyTypeEnum_GIRDER, /** Assembled reinforcement elements.*/ kIfcElementAssemblyTypeEnum_REINFORCEMENT_UNIT, /** A structure built up of beams, columns, etc. with moment-resisting joints, such as gantry*/ kIfcElementAssemblyTypeEnum_RIGID_FRAME, /** Slabs, laid out in one plane.*/ kIfcElementAssemblyTypeEnum_SLAB_FIELD, /** A structure built up of members with (quasi) pinned joint.*/ kIfcElementAssemblyTypeEnum_TRUSS, /** User-defined element assembly.*/ kIfcElementAssemblyTypeEnum_USERDEFINED, /** Undefined element assembly.*/ kIfcElementAssemblyTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcElementAssemblyTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcElementAssemblyTypeEnum& getUnset() { static OdIfc2x3::IfcElementAssemblyTypeEnum nullEnum = OdIfc2x3::kIfcElementAssemblyTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcElementCompositionEnum& getUnset() { static OdIfc2x3::IfcElementCompositionEnum nullEnum = OdIfc2x3::kIfcElementCompositionEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration is used to identify the sequence of usage of the energy source. */ enum IfcEnergySequenceEnum { /** Primary energy source.*/ kIfcEnergySequenceEnum_PRIMARY, /** Secondary energy source.*/ kIfcEnergySequenceEnum_SECONDARY, /** Tertiary energy source.*/ kIfcEnergySequenceEnum_TERTIARY, /** Auxiliary.*/ kIfcEnergySequenceEnum_AUXILIARY, /** User-defined.*/ kIfcEnergySequenceEnum_USERDEFINED, /** Not defined.*/ kIfcEnergySequenceEnum_NOTDEFINED, /** The value is unset.*/ kIfcEnergySequenceEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcEnergySequenceEnum& getUnset() { static OdIfc2x3::IfcEnergySequenceEnum nullEnum = OdIfc2x3::kIfcEnergySequenceEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcEnvironmentalImpactCategoryEnum defines the range of categories into which an environmental impact can be broken down and from which the category required may be selected. */ enum IfcEnvironmentalImpactCategoryEnum { /** An environmental impact value is deduced from values in more than one category as a result of using the applied value relationship.*/ kIfcEnvironmentalImpactCategoryEnum_COMBINEDVALUE, /** An environmental impact value due to disposal.*/ kIfcEnvironmentalImpactCategoryEnum_DISPOSAL, /** An environmental impact value due to extraction.*/ kIfcEnvironmentalImpactCategoryEnum_EXTRACTION, /** An environmental impact value due to installation.*/ kIfcEnvironmentalImpactCategoryEnum_INSTALLATION, /** An environmental impact value due to manufacture and manufacturing processes.*/ kIfcEnvironmentalImpactCategoryEnum_MANUFACTURE, /** An environmental impact value due to transportation.*/ kIfcEnvironmentalImpactCategoryEnum_TRANSPORTATION, /** User-defined.*/ kIfcEnvironmentalImpactCategoryEnum_USERDEFINED, /** Not defined.*/ kIfcEnvironmentalImpactCategoryEnum_NOTDEFINED, /** The value is unset.*/ kIfcEnvironmentalImpactCategoryEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcEnvironmentalImpactCategoryEnum& getUnset() { static OdIfc2x3::IfcEnvironmentalImpactCategoryEnum nullEnum = OdIfc2x3::kIfcEnvironmentalImpactCategoryEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details Enumeration defining the typical types of evaporative coolers. */ enum IfcEvaporativeCoolerTypeEnum { /** Direct evaporative random media air cooler: Cools the air stream by evaporating water dircectly into the air stream using coolers with evaporative pads, usually of aspen wood or plastic fiber/foam.*/ kIfcEvaporativeCoolerTypeEnum_DIRECTEVAPORATIVERANDOMMEDIAAIRCOOLER, /** Direct evaporative rigid media air cooler: Cools the air stream by evaporating water dircectly into the air stream using coolers with sheets of rigid, corrugated material as the wetted surface.*/ kIfcEvaporativeCoolerTypeEnum_DIRECTEVAPORATIVERIGIDMEDIAAIRCOOLER, /** Direct evaporative slingers packaged air cooler: Cools the air stream by evaporating water dircectly into the air stream using coolers with a water slinger in an evaporative cooling section and a fan section.*/ kIfcEvaporativeCoolerTypeEnum_DIRECTEVAPORATIVESLINGERSPACKAGEDAIRCOOLER, /** Direct evaporative packaged rotary air cooler: Cools the air stream by evaporating water dircectly into the air stream using coolers that wet and wash the evaporative pad by rotating it through a water bath.*/ kIfcEvaporativeCoolerTypeEnum_DIRECTEVAPORATIVEPACKAGEDROTARYAIRCOOLER, /** Direct evaporative air washer: Cools the air stream by evaporating water dircectly into the air stream using coolers with spray-type air washer consist of a chamber or casing containing spray nozzles, and tank for collecting spray water, and an eliminator section for removing entrained drops of water from the air.*/ kIfcEvaporativeCoolerTypeEnum_DIRECTEVAPORATIVEAIRWASHER, /** Indirect evaporative package air cooler: Cools the air stream by evaporating water indirectly and without adding moisture into the air stream. On one side of the heat exchanger, the secondary air stream is cooled by evaporation, while on the other side of heat exchanger, the primary air stream (conditioned air to be supplied to the room) is sensibly cooled by the heat exchanger surfaces.*/ kIfcEvaporativeCoolerTypeEnum_INDIRECTEVAPORATIVEPACKAGEAIRCOOLER, /** Indirect evaporative wet coil: Cools the air stream by evaporating water indirectly and without adding moisture into the air stream. Water is sprayed directly on the tubes of the heat exchanger where latent cooling takes place and the vaporization of the water on the outside of the heat exchanger tubes allows the simultaneous heat and mass transfer which removes heat from the supply air on the tube side.*/ kIfcEvaporativeCoolerTypeEnum_INDIRECTEVAPORATIVEWETCOIL, /** Indirect evaporative cooling tower or coil cooler: Cools the air stream by evaporating water indirectly and without adding moisture into the air stream using a combination of a cooling tower or other evaporative water cooler with a water-to-air heat exchanger coil and water circulating pump.*/ kIfcEvaporativeCoolerTypeEnum_INDIRECTEVAPORATIVECOOLINGTOWERORCOILCOOLER, /** Indirect/Direct combination: Cools the air stream by evaporating water indirectly and without adding moisture into the air stream using a two-stage cooler with a first-stage indirect evaporative cooler and second-stage direct evaporative cooler.*/ kIfcEvaporativeCoolerTypeEnum_INDIRECTDIRECTCOMBINATION, /** User-defined evaporative cooler type.*/ kIfcEvaporativeCoolerTypeEnum_USERDEFINED, /** Undefined evaporative cooler type.*/ kIfcEvaporativeCoolerTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcEvaporativeCoolerTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcEvaporativeCoolerTypeEnum& getUnset() { static OdIfc2x3::IfcEvaporativeCoolerTypeEnum nullEnum = OdIfc2x3::kIfcEvaporativeCoolerTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details Enumeration defining the typical types of evaporators. */ enum IfcEvaporatorTypeEnum { /** Direct-expansion evaporator where a refrigerant evaporates inside a series of baffles that channel the fluid throughout the shell side.*/ kIfcEvaporatorTypeEnum_DIRECTEXPANSIONSHELLANDTUBE, /** Direct-expansion evaporator where a refrigerant evaporates inside one or more pairs of coaxial tubes.*/ kIfcEvaporatorTypeEnum_DIRECTEXPANSIONTUBEINTUBE, /** Direct-expansion evaporator where a refrigerant evaporates inside plates brazed or welded together to make up an assembly of separate channels.*/ kIfcEvaporatorTypeEnum_DIRECTEXPANSIONBRAZEDPLATE, /** Evaporator in which refrigerant evaporates outside tubes.*/ kIfcEvaporatorTypeEnum_FLOODEDSHELLANDTUBE, /** Evaporator in which refrigerant evaporates inside a simple coiled tube immersed in the fluid to be cooled.*/ kIfcEvaporatorTypeEnum_SHELLANDCOIL, /** User-defined evaporator type.*/ kIfcEvaporatorTypeEnum_USERDEFINED, /** Undefined evaporator type.*/ kIfcEvaporatorTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcEvaporatorTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcEvaporatorTypeEnum& getUnset() { static OdIfc2x3::IfcEvaporatorTypeEnum nullEnum = OdIfc2x3::kIfcEvaporatorTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details Enumeration defining the typical types of fans. */ enum IfcFanTypeEnum { /** Air flows through the impeller radially using blades that are forward curved.*/ kIfcFanTypeEnum_CENTRIFUGALFORWARDCURVED, /** Air flows through the impeller radially using blades that are uncurved or slightly forward curved.*/ kIfcFanTypeEnum_CENTRIFUGALRADIAL, /** Air flows through the impeller radially using blades that are backward curved.*/ kIfcFanTypeEnum_CENTRIFUGALBACKWARDINCLINEDCURVED, /** Air flows through the impeller radially using blades that are airfoil shaped.*/ kIfcFanTypeEnum_CENTRIFUGALAIRFOIL, /** Air flows through the impeller axially with reduced tip clearance and operating at higher tip speeds.*/ kIfcFanTypeEnum_TUBEAXIAL, /** Air flows through the impeller axially with guide vanes and reduced running blade tip clearance.*/ kIfcFanTypeEnum_VANEAXIAL, /** Air flows through the impeller axially and small hub-to-tip ratio impeller mounted in an orifice plate or inlet ring.*/ kIfcFanTypeEnum_PROPELLORAXIAL, /** User-defined fan type.*/ kIfcFanTypeEnum_USERDEFINED, /** Undefined fan type.*/ kIfcFanTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcFanTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcFanTypeEnum& getUnset() { static OdIfc2x3::IfcFanTypeEnum nullEnum = OdIfc2x3::kIfcFanTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration defines the various types of filter typically used within building services distribution systems: */ enum IfcFilterTypeEnum { /** A filter used to remove particulates from air.*/ kIfcFilterTypeEnum_AIRPARTICLEFILTER, /** A filter used to remove odors from air.*/ kIfcFilterTypeEnum_ODORFILTER, /** A filter used to remove particulates from oil.*/ kIfcFilterTypeEnum_OILFILTER, /** A filter used to remove particulates from a fluid.*/ kIfcFilterTypeEnum_STRAINER, /** A filter used to remove particulates from water.*/ kIfcFilterTypeEnum_WATERFILTER, /** User-defined filter type.*/ kIfcFilterTypeEnum_USERDEFINED, /** Undefined filter type.*/ kIfcFilterTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcFilterTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcFilterTypeEnum& getUnset() { static OdIfc2x3::IfcFilterTypeEnum nullEnum = OdIfc2x3::kIfcFilterTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcFireSuppressionTerminalTypeEnum defines the range of different types of fire suppression terminal that can be specified. */ enum IfcFireSuppressionTerminalTypeEnum { /** Symmetrical pipe fitting that unites two or more inlets into a single pipe. A breeching inlet may be used on either a wet or dry riser. Used by fire services personnel for fast connection of fire appliance hose reels. May also be used for foam.*/ kIfcFireSuppressionTerminalTypeEnum_BREECHINGINLET, /** Device, fitted to a pipe, through which a temporary supply of water may be provided. May also be termed a stand pipe.*/ kIfcFireSuppressionTerminalTypeEnum_FIREHYDRANT, /** A supporting framework on which a hose may be wound.*/ kIfcFireSuppressionTerminalTypeEnum_HOSEREEL, /** Device for sprinkling water from a pipe under pressure over an area.*/ kIfcFireSuppressionTerminalTypeEnum_SPRINKLER, /** Device attached to a sprinkler to deflect the water flow into a spread pattern to cover the required area.*/ kIfcFireSuppressionTerminalTypeEnum_SPRINKLERDEFLECTOR, /** User-defined type*/ kIfcFireSuppressionTerminalTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcFireSuppressionTerminalTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcFireSuppressionTerminalTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcFireSuppressionTerminalTypeEnum& getUnset() { static OdIfc2x3::IfcFireSuppressionTerminalTypeEnum nullEnum = OdIfc2x3::kIfcFireSuppressionTerminalTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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, /** Undefined flow direction.*/ kIfcFlowDirectionEnum_NOTDEFINED, /** The value is unset.*/ kIfcFlowDirectionEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcFlowDirectionEnum& getUnset() { static OdIfc2x3::IfcFlowDirectionEnum nullEnum = OdIfc2x3::kIfcFlowDirectionEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcFlowInstrumentTypeEnum defines the range of different types of flow instrument that can be specified. */ enum IfcFlowInstrumentTypeEnum { /** A device that reads and displays a pressure value at a point or the pressure difference between two points.*/ kIfcFlowInstrumentTypeEnum_PRESSUREGAUGE, /** A device that reads and displays a temperature value at a point.*/ kIfcFlowInstrumentTypeEnum_THERMOMETER, /** A device that reads and displays the current flow in a circuit.*/ kIfcFlowInstrumentTypeEnum_AMMETER, /** A device that reads and displays the electrical frequency of an alternating current circuit.*/ kIfcFlowInstrumentTypeEnum_FREQUENCYMETER, /** A device that reads and displays the power factor of an electrical circuit.*/ kIfcFlowInstrumentTypeEnum_POWERFACTORMETER, /** A device that reads and displays the phase angle of a phase in a polyphase electrical circuit.*/ kIfcFlowInstrumentTypeEnum_PHASEANGLEMETER, /** A device that reads and displays the peak voltage in an electrical circuit.*/ kIfcFlowInstrumentTypeEnum_VOLTMETER_PEAK, /** A device that reads and displays the RMS (mean) voltage in an electrical circuit.*/ kIfcFlowInstrumentTypeEnum_VOLTMETER_RMS, /** User-defined type.*/ kIfcFlowInstrumentTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcFlowInstrumentTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcFlowInstrumentTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcFlowInstrumentTypeEnum& getUnset() { static OdIfc2x3::IfcFlowInstrumentTypeEnum nullEnum = OdIfc2x3::kIfcFlowInstrumentTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration defines various types of flow meter: */ enum IfcFlowMeterTypeEnum { /** An electric meter.*/ kIfcFlowMeterTypeEnum_ELECTRICMETER, /** An electric meter or energy meter is a device that measures the amount of electrical energy supplied to or produced by a residence, business or machine.*/ kIfcFlowMeterTypeEnum_ENERGYMETER, kIfcFlowMeterTypeEnum_FLOWMETER, /** A device that measures the quantity of a gas or fuel.*/ kIfcFlowMeterTypeEnum_GASMETER, /** A device that measures the quantity of oil.*/ kIfcFlowMeterTypeEnum_OILMETER, /** A device that measures the quantity of water.*/ kIfcFlowMeterTypeEnum_WATERMETER, /** User-defined meter type*/ kIfcFlowMeterTypeEnum_USERDEFINED, /** Undefined meter type*/ kIfcFlowMeterTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcFlowMeterTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcFlowMeterTypeEnum& getUnset() { static OdIfc2x3::IfcFlowMeterTypeEnum nullEnum = OdIfc2x3::kIfcFlowMeterTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details Enumeration defining the generic footing type. */ enum IfcFootingTypeEnum { /** Footing elements that are in bending and are supported clear of the ground. They will normally span between piers, piles or pile caps. They are distinguished from beams in the building superstructure since they will normally require a lower grade of finish. They are distinguished from STRIP_FOOTING since they are clear of the ground surface and hence require support to the lower face while the concrete is curing.*/ kIfcFootingTypeEnum_FOOTING_BEAM, /** An element that transfers the load of a single column (possibly two) to the ground.*/ kIfcFootingTypeEnum_PAD_FOOTING, /** An element that transfers the load from a column or group of columns to a pier or pile or group of piers or piles.*/ kIfcFootingTypeEnum_PILE_CAP, /** A linear element that transfers loads into the ground from either a continuous element, such as a wall, or from a series of elements, such as columns.*/ kIfcFootingTypeEnum_STRIP_FOOTING, /** Special types of footings which meet specific local requirements.*/ kIfcFootingTypeEnum_USERDEFINED, /** The type of footing is not defined.*/ kIfcFootingTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcFootingTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcFootingTypeEnum& getUnset() { static OdIfc2x3::IfcFootingTypeEnum nullEnum = OdIfc2x3::kIfcFootingTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details Enumeration defining the functional type of gas terminal. */ enum IfcGasTerminalTypeEnum { /** Gas appliance gas terminal type.*/ kIfcGasTerminalTypeEnum_GASAPPLIANCE, /** Gas booster gas terminal type.*/ kIfcGasTerminalTypeEnum_GASBOOSTER, kIfcGasTerminalTypeEnum_GASBURNER, /** User-defined gas terminal type.*/ kIfcGasTerminalTypeEnum_USERDEFINED, /** Not defined gas terminal type.*/ kIfcGasTerminalTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcGasTerminalTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcGasTerminalTypeEnum& getUnset() { static OdIfc2x3::IfcGasTerminalTypeEnum nullEnum = OdIfc2x3::kIfcGasTerminalTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details IfcGeometricProjectionEnum defines the various representation types that can be semantically distinguished. Often different levels of detail of the shape representation are controlled by the representation type. */ enum IfcGeometricProjectionEnum { /** Geometric display representation that shows an abstract, often 1D element representation, e.g. representing a wall by its axis line.*/ kIfcGeometricProjectionEnum_GRAPH_VIEW, /** Geometric display representation that shows an abstract, often 2D element representation, e.g. representing a wall by its two foot print edges, suppressing any inner layer representation.*/ kIfcGeometricProjectionEnum_SKETCH_VIEW, /** Geometric display representation that shows a full 3D element representation, e.g. representing a wall by its volumetric body.*/ kIfcGeometricProjectionEnum_MODEL_VIEW, /** Geometric display representation that shows a full 2D element representation, the level of detail often depends on the target scale, e.g. representing a wall by its two foot print edges and the edges of all inner layers. The projection is shown in ground view as seen from above.*/ kIfcGeometricProjectionEnum_PLAN_VIEW, /** Geometric display representation that shows a full 2D element representation, the level of detail often depends on the target scale, e.g. representing a wall by its two foot print edges and the edges of all inner layers. The projection is shown in ground view as seen from below.*/ kIfcGeometricProjectionEnum_REFLECTED_PLAN_VIEW, /** Geometric display representation that shows a full 2D element representation, the level of detail often depends on the target scale, e.g. representing a wall by its two inner/outer edges and the edges of all inner layers, if the element is cut by the section line.*/ kIfcGeometricProjectionEnum_SECTION_VIEW, /** Geometric display representation that shows a full 2D element representation, the level of detail often depends on the target scale, e.g. representing a wall by its bounding edges if the element is within an elevation view.*/ kIfcGeometricProjectionEnum_ELEVATION_VIEW, /** A user defined specification is given by the value of the UserDefinedTargetView attribute.*/ kIfcGeometricProjectionEnum_USERDEFINED, /** No specification given.*/ kIfcGeometricProjectionEnum_NOTDEFINED, /** The value is unset.*/ kIfcGeometricProjectionEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcGeometricProjectionEnum& getUnset() { static OdIfc2x3::IfcGeometricProjectionEnum nullEnum = OdIfc2x3::kIfcGeometricProjectionEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration type defines if the local object coordinate system or the global world coordinate system for the project is used to describe the measure values of entities which have a reference to this type. */ enum IfcGlobalOrLocalEnum { /** The global project coordinate system is used.*/ kIfcGlobalOrLocalEnum_GLOBAL_COORDS, /** The local object coordinate system is used.*/ kIfcGlobalOrLocalEnum_LOCAL_COORDS, /** The value is unset.*/ kIfcGlobalOrLocalEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcGlobalOrLocalEnum& getUnset() { static OdIfc2x3::IfcGlobalOrLocalEnum nullEnum = OdIfc2x3::kIfcGlobalOrLocalEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details Enumeration defining the typical types of heat exchangers. */ enum IfcHeatExchangerTypeEnum { /** Plate heat exchanger.*/ kIfcHeatExchangerTypeEnum_PLATE, /** Shell and Tube heat exchanger.*/ kIfcHeatExchangerTypeEnum_SHELLANDTUBE, /** User-defined heat exchanger type.*/ kIfcHeatExchangerTypeEnum_USERDEFINED, /** Undefined heat exchanger type.*/ kIfcHeatExchangerTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcHeatExchangerTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcHeatExchangerTypeEnum& getUnset() { static OdIfc2x3::IfcHeatExchangerTypeEnum nullEnum = OdIfc2x3::kIfcHeatExchangerTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details Enumeration defining the typical types of humidifiers. */ enum IfcHumidifierTypeEnum { /** Water vapor is added into the airstream through direct steam injection.*/ kIfcHumidifierTypeEnum_STEAMINJECTION, /** Water vapor is added into the airstream through adiabatic evaporation using an air washing element.*/ kIfcHumidifierTypeEnum_ADIABATICAIRWASHER, /** Water vapor is added into the airstream through adiabatic evaporation using a pan.*/ kIfcHumidifierTypeEnum_ADIABATICPAN, /** Water vapor is added into the airstream through adiabatic evaporation using a wetted element.*/ kIfcHumidifierTypeEnum_ADIABATICWETTEDELEMENT, /** Water vapor is added into the airstream through adiabatic evaporation using an atomizing element.*/ kIfcHumidifierTypeEnum_ADIABATICATOMIZING, /** Water vapor is added into the airstream through adiabatic evaporation using an ultrasonic element.*/ kIfcHumidifierTypeEnum_ADIABATICULTRASONIC, /** Water vapor is added into the airstream through adiabatic evaporation using a rigid media.*/ kIfcHumidifierTypeEnum_ADIABATICRIGIDMEDIA, /** Water vapor is added into the airstream through adiabatic evaporation using a compressed air nozzle.*/ kIfcHumidifierTypeEnum_ADIABATICCOMPRESSEDAIRNOZZLE, /** Water vapor is added into the airstream through water heated evaporation using an electric heater.*/ kIfcHumidifierTypeEnum_ASSISTEDELECTRIC, /** Water vapor is added into the airstream through water heated evaporation using a natural gas heater.*/ kIfcHumidifierTypeEnum_ASSISTEDNATURALGAS, /** Water vapor is added into the airstream through water heated evaporation using a propane heater.*/ kIfcHumidifierTypeEnum_ASSISTEDPROPANE, /** Water vapor is added into the airstream through water heated evaporation using a butane heater.*/ kIfcHumidifierTypeEnum_ASSISTEDBUTANE, /** Water vapor is added into the airstream through water heated evaporation using a steam heater.*/ kIfcHumidifierTypeEnum_ASSISTEDSTEAM, /** User-defined humidifier type.*/ kIfcHumidifierTypeEnum_USERDEFINED, /** Undefined humidifier type.*/ kIfcHumidifierTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcHumidifierTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcHumidifierTypeEnum& getUnset() { static OdIfc2x3::IfcHumidifierTypeEnum nullEnum = OdIfc2x3::kIfcHumidifierTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcInternalOrExternalEnum& getUnset() { static OdIfc2x3::IfcInternalOrExternalEnum nullEnum = OdIfc2x3::kIfcInternalOrExternalEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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, /** User-defined type.*/ kIfcInventoryTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcInventoryTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcInventoryTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcInventoryTypeEnum& getUnset() { static OdIfc2x3::IfcInventoryTypeEnum nullEnum = OdIfc2x3::kIfcInventoryTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcJunctionBoxTypeEnum defines different types of junction boxes. */ enum IfcJunctionBoxTypeEnum { /** User-defined type.*/ kIfcJunctionBoxTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcJunctionBoxTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcJunctionBoxTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcJunctionBoxTypeEnum& getUnset() { static OdIfc2x3::IfcJunctionBoxTypeEnum nullEnum = OdIfc2x3::kIfcJunctionBoxTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcLampTypeEnum defines the range of different types of lamp available. */ enum IfcLampTypeEnum { /** A fluorescent lamp having a compact form factor produced by shaping the tube.*/ kIfcLampTypeEnum_COMPACTFLUORESCENT, /** A typically tubular discharge lamp in which most of the light is emitted by one or several layers of phosphors excited by ultraviolet radiation from the discharge.*/ kIfcLampTypeEnum_FLUORESCENT, /** A discharge lamp in which most of the light is emitted by exciting mercury at high pressure.*/ kIfcLampTypeEnum_HIGHPRESSUREMERCURY, /** A discharge lamp in which most of the light is emitted by exciting sodium at high pressure.*/ kIfcLampTypeEnum_HIGHPRESSURESODIUM, /** A discharge lamp in which most of the light is emitted by exciting a metal halide.*/ kIfcLampTypeEnum_METALHALIDE, /** A lamp that emits light by passing an electrical current through a tungsten wire filament in a near vacuum.*/ kIfcLampTypeEnum_TUNGSTENFILAMENT, /** User-defined type.*/ kIfcLampTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcLampTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcLampTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcLampTypeEnum& getUnset() { static OdIfc2x3::IfcLampTypeEnum nullEnum = OdIfc2x3::kIfcLampTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcLayerSetDirectionEnum& getUnset() { static OdIfc2x3::IfcLayerSetDirectionEnum nullEnum = OdIfc2x3::kIfcLayerSetDirectionEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details Enumerates possible three kinds of light distribution curves. */ enum IfcLightDistributionCurveEnum { /** Type A is basically not used. For completeness the Type A Photometry equals the Type B rotated 90° around the Z-Axis counter clockwise.*/ kIfcLightDistributionCurveEnum_TYPE_A, /** Type B is sometimes used for floodlights. The B-Plane System has a horizontal axis. B-Angles are valid from -180° to +180° with B 0° at the bottom and B180°/B-180° at the top, β-Angles are valid from -90° to +90°.*/ kIfcLightDistributionCurveEnum_TYPE_B, /** Type C is the recommended standard system. The C-Plane system equals a globe with a vertical axis. C-Angles are valid from 0° to 360°, γ-Angles are valid from 0° (south pole) to 180° (north pole).*/ kIfcLightDistributionCurveEnum_TYPE_C, /** Not defined.*/ kIfcLightDistributionCurveEnum_NOTDEFINED, /** The value is unset.*/ kIfcLightDistributionCurveEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcLightDistributionCurveEnum& getUnset() { static OdIfc2x3::IfcLightDistributionCurveEnum nullEnum = OdIfc2x3::kIfcLightDistributionCurveEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details IfcLightEmissionSourceEnum defines the range of different types of light emitter available. */ enum IfcLightEmissionSourceEnum { /** Compact fluorescent*/ kIfcLightEmissionSourceEnum_COMPACTFLUORESCENT, /** Fluorescent*/ kIfcLightEmissionSourceEnum_FLUORESCENT, /** High pressure mercury*/ kIfcLightEmissionSourceEnum_HIGHPRESSUREMERCURY, /** High pressure sodium*/ kIfcLightEmissionSourceEnum_HIGHPRESSURESODIUM, /** Light emitting diode*/ kIfcLightEmissionSourceEnum_LIGHTEMITTINGDIODE, /** Low pressure sodium*/ kIfcLightEmissionSourceEnum_LOWPRESSURESODIUM, /** Low voltage halogen*/ kIfcLightEmissionSourceEnum_LOWVOLTAGEHALOGEN, /** Main voltage halogen*/ kIfcLightEmissionSourceEnum_MAINVOLTAGEHALOGEN, /** Metal halide*/ kIfcLightEmissionSourceEnum_METALHALIDE, /** Tungsten filament*/ kIfcLightEmissionSourceEnum_TUNGSTENFILAMENT, /** Not defined.*/ kIfcLightEmissionSourceEnum_NOTDEFINED, /** The value is unset.*/ kIfcLightEmissionSourceEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcLightEmissionSourceEnum& getUnset() { static OdIfc2x3::IfcLightEmissionSourceEnum nullEnum = OdIfc2x3::kIfcLightEmissionSourceEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcLightFixtureTypeEnum defines the different types of light fixtures. */ enum IfcLightFixtureTypeEnum { /** A light fixture that is considered to have negligible area and that emit light with approximately equal intensity in all directions. A light fixture containing a tungsten, halogen or similar bulb is an example of a point source.*/ kIfcLightFixtureTypeEnum_POINTSOURCE, /** A light fixture that is considered to have a length or surface area from which it emits light in a direction. A light fixture containing one or more fluorescent lamps is an example of a direction source.*/ kIfcLightFixtureTypeEnum_DIRECTIONSOURCE, /** User-defined type.*/ kIfcLightFixtureTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcLightFixtureTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcLightFixtureTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcLightFixtureTypeEnum& getUnset() { static OdIfc2x3::IfcLightFixtureTypeEnum nullEnum = OdIfc2x3::kIfcLightFixtureTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration is used to distinguish between different levels of load grouping. It allows to differentiate between load groups, load cases, and load combinations. */ enum IfcLoadGroupTypeEnum { /** Groups instances of subtypes of IfcStructuralAction. It shall be used as a container for loads grouped together for specific purposes, such as loads which are part of a special load pattern.*/ kIfcLoadGroupTypeEnum_LOAD_GROUP, /** Groups LOAD_GROUPs and instances of subtypes of IfcStructuralAction. It should be used as a container for loads with the same origin.*/ kIfcLoadGroupTypeEnum_LOAD_CASE, /** Groups LOAD_CASEs and assigns a common load combination factor. The grouping of LOAD_GROUPs and instances of IfcStructuralAction or its subclasses is also possible, but off the traditional way.*/ kIfcLoadGroupTypeEnum_LOAD_COMBINATION_GROUP, /** An intermediate level between LOAD_CASE and LOAD_COMBINATION. This level is obsolete and deprecated. Before the introduction of IfcRelAssignsToGroupByFactor, the purpose of this level was to provide a factor with which one or more LOAD_CASEs occur in a LOAD_COMBINATION.*/ kIfcLoadGroupTypeEnum_LOAD_COMBINATION, /** A grouping level which does not follow the standard hierarchy of load group types.*/ kIfcLoadGroupTypeEnum_USERDEFINED, /** The grouping level is not yet known.*/ kIfcLoadGroupTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcLoadGroupTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcLoadGroupTypeEnum& getUnset() { static OdIfc2x3::IfcLoadGroupTypeEnum nullEnum = OdIfc2x3::kIfcLoadGroupTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details IfcLogicalOperatorEnum is an enumeration that defines the logical operators that may be applied for the satisfaction of one or more operands (IfcConstraint) at a time. */ enum IfcLogicalOperatorEnum { /** Defines a relationship between operands whereby the result is true if all operands are true, and false if at least one operand is false.*/ kIfcLogicalOperatorEnum_LOGICALAND, /** Defines a relationship between operands whereby the result is true if at least one operand is true, and false if all operands are false.*/ kIfcLogicalOperatorEnum_LOGICALOR, /** The value is unset.*/ kIfcLogicalOperatorEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcLogicalOperatorEnum& getUnset() { static OdIfc2x3::IfcLogicalOperatorEnum nullEnum = OdIfc2x3::kIfcLogicalOperatorEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration defines the different types of linear elements an IfcMember or IfcMemberType object can fulfill. */ enum IfcMemberTypeEnum { /** A linear element (usually sloped) often used for bracing of a girder or truss.*/ kIfcMemberTypeEnum_BRACE, /** Upper or lower longitudinal member of a truss, used horizontally or sloped.*/ kIfcMemberTypeEnum_CHORD, /** A linear element (usually used horizontally) within a roof structure to connect rafters and posts.*/ kIfcMemberTypeEnum_COLLAR, /** A linear element within a girder or truss with no further meaning.*/ kIfcMemberTypeEnum_MEMBER, /** A linear element within a curtain wall system to connect two (or more) panels.*/ kIfcMemberTypeEnum_MULLION, /** A linear continuous horizontal element in wall framing, such as a head piece or a sole plate.*/ kIfcMemberTypeEnum_PLATE, /** A linear (usually vertical) member used to support something or to mark a point.*/ kIfcMemberTypeEnum_POST, /** A linear element (usually used horizontally) within a roof structure to support rafters.*/ kIfcMemberTypeEnum_PURLIN, /** A linear elements used to support roof slabs or roof covering, usually used with slope.*/ kIfcMemberTypeEnum_RAFTER, /** A linear element used to support stair or ramp flights, usually used with slope.*/ kIfcMemberTypeEnum_STRINGER, /** A linear element often used within a girder or truss.*/ kIfcMemberTypeEnum_STRUT, /** Vertical element in wall framing.*/ kIfcMemberTypeEnum_STUD, /** User-defined linear element.*/ kIfcMemberTypeEnum_USERDEFINED, /** Undefined linear element.*/ kIfcMemberTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcMemberTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcMemberTypeEnum& getUnset() { static OdIfc2x3::IfcMemberTypeEnum nullEnum = OdIfc2x3::kIfcMemberTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcMotorConnectionTypeEnum defines the range of different types of motor connection that can be specified. */ enum IfcMotorConnectionTypeEnum { /** An indirect connection made through the medium of a shaped, flexible continuous loop.*/ kIfcMotorConnectionTypeEnum_BELTDRIVE, /** An indirect connection made through the medium of the viscosity of a fluid.*/ kIfcMotorConnectionTypeEnum_COUPLING, /** A direct, physical connection made between the motor and the driven device.*/ kIfcMotorConnectionTypeEnum_DIRECTDRIVE, /** User-defined type.*/ kIfcMotorConnectionTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcMotorConnectionTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcMotorConnectionTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcMotorConnectionTypeEnum& getUnset() { static OdIfc2x3::IfcMotorConnectionTypeEnum nullEnum = OdIfc2x3::kIfcMotorConnectionTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcNullStyle is an enumeration with a fixed value NULL to indicate that no presentation style is defined for the representation item. */ enum IfcNullStyle { kIfcNullStyle_NULL, /** The value is unset.*/ kIfcNullStyle_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcNullStyle& getUnset() { static OdIfc2x3::IfcNullStyle nullEnum = OdIfc2x3::kIfcNullStyle_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcObjectTypeEnum& getUnset() { static OdIfc2x3::IfcObjectTypeEnum nullEnum = OdIfc2x3::kIfcObjectTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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, /** A constraint whose objective is to ensure satisfaction of a health and safety provision.*/ kIfcObjectiveEnum_HEALTHANDSAFETY, /** A constraint whose objective is to ensure satisfaction of a project requirement provision.*/ kIfcObjectiveEnum_REQUIREMENT, /** A constraint whose objective is to ensure satisfaction of a specification provision.*/ kIfcObjectiveEnum_SPECIFICATION, /** A constraint whose objective is to indicate a limiting value beyond which the condition of an object requires a particular form of attention.*/ kIfcObjectiveEnum_TRIGGERCONDITION, /** No description available.*/ kIfcObjectiveEnum_USERDEFINED, /** No description available.*/ kIfcObjectiveEnum_NOTDEFINED, /** The value is unset.*/ kIfcObjectiveEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcObjectiveEnum& getUnset() { static OdIfc2x3::IfcObjectiveEnum nullEnum = OdIfc2x3::kIfcObjectiveEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details IfcOccupantTypeEnum defines the types of occupant from which the type required can be selected. */ enum IfcOccupantTypeEnum { /** Actor receiving the assignment of a property agreement from an assignor.*/ kIfcOccupantTypeEnum_ASSIGNEE, /** Actor assigning a property agreement to an assignor.*/ kIfcOccupantTypeEnum_ASSIGNOR, /** Actor receiving the lease of a property from a lessor.*/ kIfcOccupantTypeEnum_LESSEE, /** Actor leasing a property to a lessee.*/ kIfcOccupantTypeEnum_LESSOR, /** Actor participating in a property agreement on behalf of an owner, lessor or assignor.*/ kIfcOccupantTypeEnum_LETTINGAGENT, /** Actor that owns a property.*/ kIfcOccupantTypeEnum_OWNER, /** Actor renting the use of a property fro a period of time.*/ kIfcOccupantTypeEnum_TENANT, /** User-defined type.*/ kIfcOccupantTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcOccupantTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcOccupantTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcOccupantTypeEnum& getUnset() { static OdIfc2x3::IfcOccupantTypeEnum nullEnum = OdIfc2x3::kIfcOccupantTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcOutletTypeEnum defines the range of different types of outlet that can be specified. */ enum IfcOutletTypeEnum { /** An outlet used for an audio or visual device.*/ kIfcOutletTypeEnum_AUDIOVISUALOUTLET, /** An outlet used for connecting communications equipment.*/ kIfcOutletTypeEnum_COMMUNICATIONSOUTLET, /** 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 OdIfc2x3::IfcOutletTypeEnum& getUnset() { static OdIfc2x3::IfcOutletTypeEnum nullEnum = OdIfc2x3::kIfcOutletTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcPermeableCoveringOperationEnum& getUnset() { static OdIfc2x3::IfcPermeableCoveringOperationEnum nullEnum = OdIfc2x3::kIfcPermeableCoveringOperationEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcPhysicalOrVirtualEnum& getUnset() { static OdIfc2x3::IfcPhysicalOrVirtualEnum nullEnum = OdIfc2x3::kIfcPhysicalOrVirtualEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details Enumeration defining the construction type for piles. The type is mainly based on how the piles are used and manufactured. Some material information is mixed in because this affects the way the piles are used. */ enum IfcPileConstructionEnum { /** Piles and piers that are excavated and poured in place.*/ kIfcPileConstructionEnum_CAST_IN_PLACE, /** Piles that are a mix of components, such as a steel outer casing which is driven into the ground with a cast-in-place concrete core.*/ kIfcPileConstructionEnum_COMPOSITE, /** Piles that are entirely of precast concrete (possibly with some steel or other fixtures).*/ kIfcPileConstructionEnum_PRECAST_CONCRETE, /** Prefabricated piles made entirely out of steel. It will also include steel sheet piles where these are not part of another construction element.*/ kIfcPileConstructionEnum_PREFAB_STEEL, /** Special types of pile construction which meet specific local requirements.*/ kIfcPileConstructionEnum_USERDEFINED, /** The type of pile construction is not defined.*/ kIfcPileConstructionEnum_NOTDEFINED, /** The value is unset.*/ kIfcPileConstructionEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcPileConstructionEnum& getUnset() { static OdIfc2x3::IfcPileConstructionEnum nullEnum = OdIfc2x3::kIfcPileConstructionEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details Enumeration defining the pile type. */ enum IfcPileTypeEnum { /** A cohesion pile.*/ kIfcPileTypeEnum_COHESION, /** A friction pile.*/ kIfcPileTypeEnum_FRICTION, /** A support pile.*/ kIfcPileTypeEnum_SUPPORT, /** The type of pile function is user defined.*/ kIfcPileTypeEnum_USERDEFINED, /** The type of pile function is not defined.*/ kIfcPileTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcPileTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcPileTypeEnum& getUnset() { static OdIfc2x3::IfcPileTypeEnum nullEnum = OdIfc2x3::kIfcPileTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration is used to identify the primary purpose of a pipe fitting. This is a very basic categorization mechanism to generically identify the pipe fitting type. Subcategories of pipe fittings are not enumerated. */ enum IfcPipeFittingTypeEnum { /** A fitting with typically two ports used to change the direction of flow between connected elements.*/ kIfcPipeFittingTypeEnum_BEND, /** Connector fitting, typically used to join two ports together within a flow distribution system (e.g., a coupling used to join two pipe segments).*/ kIfcPipeFittingTypeEnum_CONNECTOR, /** Entry fitting, typically unconnected at one port and connected to a flow distribution system at the other (e.g., a breeching inlet).*/ kIfcPipeFittingTypeEnum_ENTRY, /** Exit fitting, typically unconnected at one port and connected to a flow distribution system at the other (e.g., a hose bibb).*/ kIfcPipeFittingTypeEnum_EXIT, /** 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.).*/ kIfcPipeFittingTypeEnum_JUNCTION, /** A fitting with typically two ports used to obstruct or restrict flow between the connected elements (e.g., screen, perforated plate, etc.).*/ kIfcPipeFittingTypeEnum_OBSTRUCTION, /** A fitting with typically two ports having different shapes or sizes. Can also be used to change the direction of flow between connected elements.*/ kIfcPipeFittingTypeEnum_TRANSITION, /** User-defined fitting.*/ kIfcPipeFittingTypeEnum_USERDEFINED, /** Undefined fitting.*/ kIfcPipeFittingTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcPipeFittingTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcPipeFittingTypeEnum& getUnset() { static OdIfc2x3::IfcPipeFittingTypeEnum nullEnum = OdIfc2x3::kIfcPipeFittingTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration is used to identify the primary purpose of a pipe segment. This is a very basic categorization mechanism to generically identify the pipe segment type. Subcategories of pipe segments are not enumerated. */ enum IfcPipeSegmentTypeEnum { /** A flexible segment is a continuous non-linear segment of pipe that can be deformed and change the direction of flow.*/ kIfcPipeSegmentTypeEnum_FLEXIBLESEGMENT, /** A rigid segment is continuous linear segment of pipe that cannot be deformed.*/ kIfcPipeSegmentTypeEnum_RIGIDSEGMENT, /** A gutter segment is a continuous open-channel segment of pipe.*/ kIfcPipeSegmentTypeEnum_GUTTER, /** A type of rigid segment that is typically shorter and used for providing connectivity within a piping network.*/ kIfcPipeSegmentTypeEnum_SPOOL, /** User-defined segment.*/ kIfcPipeSegmentTypeEnum_USERDEFINED, /** Undefined segment.*/ kIfcPipeSegmentTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcPipeSegmentTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcPipeSegmentTypeEnum& getUnset() { static OdIfc2x3::IfcPipeSegmentTypeEnum nullEnum = OdIfc2x3::kIfcPipeSegmentTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration defines the different types of planar elements an IfcPlate or IfcPlateType object can fulfill. */ enum IfcPlateTypeEnum { /** A planar element within a curtain wall, often consisting of a frame with fixed glazing.*/ kIfcPlateTypeEnum_CURTAIN_PANEL, /** A planar, flat and thin element, comes usually as metal sheet, and is often used as an additional part within an assembly.*/ kIfcPlateTypeEnum_SHEET, /** User-defined linear element.*/ kIfcPlateTypeEnum_USERDEFINED, /** Undefined linear element.*/ kIfcPlateTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcPlateTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcPlateTypeEnum& getUnset() { static OdIfc2x3::IfcPlateTypeEnum nullEnum = OdIfc2x3::kIfcPlateTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcProcedureTypeEnum defines the range of different types of procedure that can be specified. */ enum IfcProcedureTypeEnum { /** A caution that should be taken note of as a procedure or when carrying out a procedure.*/ kIfcProcedureTypeEnum_ADVICE_CAUTION, /** Additional information or advice that should be taken note of as a procedure or when carrying out a procedure.*/ kIfcProcedureTypeEnum_ADVICE_NOTE, /** A warning of potential danger that should be taken note of as a procedure or when carrying out a procedure.*/ kIfcProcedureTypeEnum_ADVICE_WARNING, /** A procedure undertaken to calibrate an artifact.*/ kIfcProcedureTypeEnum_CALIBRATION, /** Diagnostic*/ kIfcProcedureTypeEnum_DIAGNOSTIC, /** A procedure undertaken to shutdown the operation of an artifact.*/ kIfcProcedureTypeEnum_SHUTDOWN, /** A procedure undertaken to start up the operation of an artifact.*/ kIfcProcedureTypeEnum_STARTUP, /** User defined.*/ kIfcProcedureTypeEnum_USERDEFINED, /** Undefined.*/ kIfcProcedureTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcProcedureTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcProcedureTypeEnum& getUnset() { static OdIfc2x3::IfcProcedureTypeEnum nullEnum = OdIfc2x3::kIfcProcedureTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcProfileTypeEnum& getUnset() { static OdIfc2x3::IfcProfileTypeEnum nullEnum = OdIfc2x3::kIfcProfileTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details An IfcProjectOrderRecordTypeEnum is a designation of the type of event being recorded. */ enum IfcProjectOrderRecordTypeEnum { /** A record of instructions to bring about a change to a construction or installation.*/ kIfcProjectOrderRecordTypeEnum_CHANGE, /** A record of instructions to carry out maintenance work on one or more assets or components.*/ kIfcProjectOrderRecordTypeEnum_MAINTENANCE, /** A record of instructions to move actors and/or artifacts.*/ kIfcProjectOrderRecordTypeEnum_MOVE, /** A record of instructions to purchase goods or services.*/ kIfcProjectOrderRecordTypeEnum_PURCHASE, /** A record of instructions to carry out work generally.*/ kIfcProjectOrderRecordTypeEnum_WORK, /** User-defined record.*/ kIfcProjectOrderRecordTypeEnum_USERDEFINED, /** Not defined record.*/ kIfcProjectOrderRecordTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcProjectOrderRecordTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcProjectOrderRecordTypeEnum& getUnset() { static OdIfc2x3::IfcProjectOrderRecordTypeEnum nullEnum = OdIfc2x3::kIfcProjectOrderRecordTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details An IfcProjectOrderTypeEnum is a list of the types of project order that may be identified. */ enum IfcProjectOrderTypeEnum { /** An instruction to make a change to a product or work being undertaken and a description of the work that is to be performed.*/ kIfcProjectOrderTypeEnum_CHANGEORDER, /** An instruction to carry out maintenance work and a description of the work that is to be performed.*/ kIfcProjectOrderTypeEnum_MAINTENANCEWORKORDER, /** An instruction to move persons and artifacts and a description of the move locations, objects to be moved, etc.*/ kIfcProjectOrderTypeEnum_MOVEORDER, /** An instruction to purchase goods and/or services and a description of the goods and/or services to be purchased that is to be performed.*/ kIfcProjectOrderTypeEnum_PURCHASEORDER, /** A general instruction to carry out work and a description of the work to be done. Note the difference between a work order generally and a maintenance work order.*/ kIfcProjectOrderTypeEnum_WORKORDER, /** User-defined type.*/ kIfcProjectOrderTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcProjectOrderTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcProjectOrderTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcProjectOrderTypeEnum& getUnset() { static OdIfc2x3::IfcProjectOrderTypeEnum nullEnum = OdIfc2x3::kIfcProjectOrderTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration type is needed for load definition and is only considered if the load values are given as global actions and if they define linear or planar loads (that is, one- or two-dimensionally distributed loads). */ enum IfcProjectedOrTrueLengthEnum { /** Projected length*/ kIfcProjectedOrTrueLengthEnum_PROJECTED_LENGTH, /** True Length*/ kIfcProjectedOrTrueLengthEnum_TRUE_LENGTH, /** The value is unset.*/ kIfcProjectedOrTrueLengthEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcProjectedOrTrueLengthEnum& getUnset() { static OdIfc2x3::IfcProjectedOrTrueLengthEnum nullEnum = OdIfc2x3::kIfcProjectedOrTrueLengthEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration is used to qualify the life-cycle or design state of the properties contained in the entity. */ enum IfcPropertySourceEnum { /** Properties are all design values.*/ kIfcPropertySourceEnum_DESIGN, /** Properties are all maximum design values.*/ kIfcPropertySourceEnum_DESIGNMAXIMUM, /** Properties are all minimum design values.*/ kIfcPropertySourceEnum_DESIGNMINIMUM, /** Property values are all the results of a simulation.*/ kIfcPropertySourceEnum_SIMULATED, /** Properties are all AS-BUILT values.*/ kIfcPropertySourceEnum_ASBUILT, /** Properties are all commissioning values.*/ kIfcPropertySourceEnum_COMMISSIONING, /** Property values are all the results of a measurement device, either automated or manual.*/ kIfcPropertySourceEnum_MEASURED, /** User-defined record.*/ kIfcPropertySourceEnum_USERDEFINED, kIfcPropertySourceEnum_NOTKNOWN, /** The value is unset.*/ kIfcPropertySourceEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcPropertySourceEnum& getUnset() { static OdIfc2x3::IfcPropertySourceEnum nullEnum = OdIfc2x3::kIfcPropertySourceEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcProtectiveDeviceTypeEnum specifically defines the range of different breaker unit types that can be used in conjunction with protective device. Types may also be used as a reference to a complete protective device in circumstances where tripping units are not separately identified (typically expected to be the case during earlier stages of design). */ enum IfcProtectiveDeviceTypeEnum { /** A device that will electrically open the circuit after a period of prolonged, abnormal current flow.*/ kIfcProtectiveDeviceTypeEnum_FUSEDISCONNECTOR, /** A mechanical switching device capable of making, carrying, and breaking currents under normal circuit conditions and also making, carrying for a specified time and breaking, current under specified abnormal circuit conditions such as those of short circuit.*/ kIfcProtectiveDeviceTypeEnum_CIRCUITBREAKER, /** An earth failure device acts to protect people and equipment from the effects of current leakage.*/ kIfcProtectiveDeviceTypeEnum_EARTHFAILUREDEVICE, /** A device that opens, closes, or isolates a circuit and has short circuit and overload protection. It attempts to break the circuit when there is a difference in current between any two phases. May also be referred to as 'Ground Fault Interupter (GFI)' or 'Ground Fault Circuit Interuptor (GFCI)'*/ kIfcProtectiveDeviceTypeEnum_RESIDUALCURRENTCIRCUITBREAKER, /** A device that opens, closes or isolates a circuit and has no short circuit or overload protection. May also be identified as a 'ground fault switch'.*/ kIfcProtectiveDeviceTypeEnum_RESIDUALCURRENTSWITCH, /** A high voltage surge protection device.*/ kIfcProtectiveDeviceTypeEnum_VARISTOR, /** User-defined type.*/ kIfcProtectiveDeviceTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcProtectiveDeviceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcProtectiveDeviceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcProtectiveDeviceTypeEnum& getUnset() { static OdIfc2x3::IfcProtectiveDeviceTypeEnum nullEnum = OdIfc2x3::kIfcProtectiveDeviceTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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, /** User-defined pump type.*/ kIfcPumpTypeEnum_USERDEFINED, /** Pump type has not been defined.*/ kIfcPumpTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcPumpTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcPumpTypeEnum& getUnset() { static OdIfc2x3::IfcPumpTypeEnum nullEnum = OdIfc2x3::kIfcPumpTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcRailingTypeEnum& getUnset() { static OdIfc2x3::IfcRailingTypeEnum nullEnum = OdIfc2x3::kIfcRailingTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration defines the different types an IfcRampFlight or IfcRampFlightType object can fulfill. */ enum IfcRampFlightTypeEnum { /** A ramp flight with a straight walking line.*/ kIfcRampFlightTypeEnum_STRAIGHT, /** A ramp flight with a circular or elliptic walking line.*/ kIfcRampFlightTypeEnum_SPIRAL, /** User-defined ramp flight.*/ kIfcRampFlightTypeEnum_USERDEFINED, /** Undefined ramp flight.*/ kIfcRampFlightTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcRampFlightTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcRampFlightTypeEnum& getUnset() { static OdIfc2x3::IfcRampFlightTypeEnum nullEnum = OdIfc2x3::kIfcRampFlightTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcRampTypeEnum& getUnset() { static OdIfc2x3::IfcRampTypeEnum nullEnum = OdIfc2x3::kIfcRampTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcReflectanceMethodEnum defines the range of different reflectance methods available. */ enum IfcReflectanceMethodEnum { /** A reflectance model providing a smooth, slightly shiny appearance.*/ kIfcReflectanceMethodEnum_BLINN, /** A reflectance model conforming with the Unlit lighting model defined in X3D.*/ kIfcReflectanceMethodEnum_FLAT, /** A reflectance model that supports an approximation of glass-like materials that have both reflective and transmissive properties.*/ kIfcReflectanceMethodEnum_GLASS, /** A reflectance model providing a dull matte appearance.*/ kIfcReflectanceMethodEnum_MATT, /** A reflectance model providing a specular metallic appearance.*/ kIfcReflectanceMethodEnum_METAL, /** A reflectance model that supports secondary mirrored views through ray tracing.*/ kIfcReflectanceMethodEnum_MIRROR, /** A reflectance model conforming with the Phong lighting model defined in X3D.*/ kIfcReflectanceMethodEnum_PHONG, /** A reflectance model providing a specular effect which is similar to the Phong model.*/ kIfcReflectanceMethodEnum_PLASTIC, /** A reflectance model for metallic and non-metallic appearance based on a limited set of control parameter.*/ kIfcReflectanceMethodEnum_STRAUSS, /** Undefined.*/ kIfcReflectanceMethodEnum_NOTDEFINED, /** The value is unset.*/ kIfcReflectanceMethodEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcReflectanceMethodEnum& getUnset() { static OdIfc2x3::IfcReflectanceMethodEnum nullEnum = OdIfc2x3::kIfcReflectanceMethodEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details Enumeration defining standard types for the role, purpose or usage of the bar, i.e. the kind of loads and stresses they are intended to carry. */ enum IfcReinforcingBarRoleEnum { /** The reinforcing bar is a main bar.*/ kIfcReinforcingBarRoleEnum_MAIN, /** The reinforcing bar is a shear bar.*/ kIfcReinforcingBarRoleEnum_SHEAR, /** The reinforcing bar is a ligature (link, stirrup).*/ kIfcReinforcingBarRoleEnum_LIGATURE, /** The reinforcing bar is a stud.*/ kIfcReinforcingBarRoleEnum_STUD, /** Punching reinforcement.*/ kIfcReinforcingBarRoleEnum_PUNCHING, /** Edge reinforcement.*/ kIfcReinforcingBarRoleEnum_EDGE, /** Ring reinforcement.*/ kIfcReinforcingBarRoleEnum_RING, /** The type of reinforcement is user defined.*/ kIfcReinforcingBarRoleEnum_USERDEFINED, /** The type of reinforcement is not defined.*/ kIfcReinforcingBarRoleEnum_NOTDEFINED, /** The value is unset.*/ kIfcReinforcingBarRoleEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcReinforcingBarRoleEnum& getUnset() { static OdIfc2x3::IfcReinforcingBarRoleEnum nullEnum = OdIfc2x3::kIfcReinforcingBarRoleEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details Enumeration indicating whether the bar has a plain or textured (ribbed) surface. */ enum IfcReinforcingBarSurfaceEnum { /** The reinforcing bar surface is plain.*/ kIfcReinforcingBarSurfaceEnum_PLAIN, /** The reinforcing bar surface is textured (ribbed).*/ kIfcReinforcingBarSurfaceEnum_TEXTURED, /** The value is unset.*/ kIfcReinforcingBarSurfaceEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcReinforcingBarSurfaceEnum& getUnset() { static OdIfc2x3::IfcReinforcingBarSurfaceEnum nullEnum = OdIfc2x3::kIfcReinforcingBarSurfaceEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcResourceConsumptionEnum& getUnset() { static OdIfc2x3::IfcResourceConsumptionEnum nullEnum = OdIfc2x3::kIfcResourceConsumptionEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration type specifies the axis which is used for the definition of the profile properties. This differentiation is only needed for the definition of profile properties of face members. */ enum IfcRibPlateDirectionEnum { /** X-axis direction.*/ kIfcRibPlateDirectionEnum_DIRECTION_X, /** Y-axis direction.*/ kIfcRibPlateDirectionEnum_DIRECTION_Y, /** The value is unset.*/ kIfcRibPlateDirectionEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcRibPlateDirectionEnum& getUnset() { static OdIfc2x3::IfcRibPlateDirectionEnum nullEnum = OdIfc2x3::kIfcRibPlateDirectionEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcRoleEnum& getUnset() { static OdIfc2x3::IfcRoleEnum nullEnum = OdIfc2x3::kIfcRoleEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcRoofTypeEnum& getUnset() { static OdIfc2x3::IfcRoofTypeEnum nullEnum = OdIfc2x3::kIfcRoofTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcSIPrefix& getUnset() { static OdIfc2x3::IfcSIPrefix nullEnum = OdIfc2x3::kIfcSIPrefix_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcSIUnitName& getUnset() { static OdIfc2x3::IfcSIUnitName nullEnum = OdIfc2x3::kIfcSIUnitName_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcSanitaryTerminalTypeEnum defines the range of different types of sanitary terminal that can be specified. */ enum IfcSanitaryTerminalTypeEnum { /** Sanitary appliance for immersion of the human body or parts of it.*/ kIfcSanitaryTerminalTypeEnum_BATH, /** Waste water appliance for washing the excretory organs while sitting astride the bowl.*/ kIfcSanitaryTerminalTypeEnum_BIDET, /** A water storage unit attached to a sanitary terminal that is fitted with a device, operated automatically or by the user, that discharges water to cleanse a water closet (toilet) pan, urinal or slop hopper.*/ kIfcSanitaryTerminalTypeEnum_CISTERN, /** 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, /** A sanitary terminal that provides a low pressure jet of water for a specific purpose.*/ kIfcSanitaryTerminalTypeEnum_SANITARYFOUNTAIN, /** Soil appliance for the disposal of excrement.*/ kIfcSanitaryTerminalTypeEnum_TOILETPAN, /** Soil appliance that receives urine and directs it to a waste outlet.*/ kIfcSanitaryTerminalTypeEnum_URINAL, /** Waste water appliance for washing the upper parts of the body.*/ kIfcSanitaryTerminalTypeEnum_WASHHANDBASIN, /** [Deprecated] Hinged seat that fits on the top of a water closet (WC) pan.*/ kIfcSanitaryTerminalTypeEnum_WCSEAT, /** User-defined type.*/ kIfcSanitaryTerminalTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcSanitaryTerminalTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcSanitaryTerminalTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcSanitaryTerminalTypeEnum& getUnset() { static OdIfc2x3::IfcSanitaryTerminalTypeEnum nullEnum = OdIfc2x3::kIfcSanitaryTerminalTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details An enumeration indicating whether a specific piece of a cross section is uniform or tapered in longitudinal direction. */ enum IfcSectionTypeEnum { /** The section is uniform in longitudinal direction.*/ kIfcSectionTypeEnum_UNIFORM, /** The section is tapered in longitudinal direction.*/ kIfcSectionTypeEnum_TAPERED, /** The value is unset.*/ kIfcSectionTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcSectionTypeEnum& getUnset() { static OdIfc2x3::IfcSectionTypeEnum nullEnum = OdIfc2x3::kIfcSectionTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcSensorTypeEnum defines the range of different types of sensor that can be specified. */ enum IfcSensorTypeEnum { /** A device that senses or detects carbon dioxide.*/ kIfcSensorTypeEnum_CO2SENSOR, /** A device that senses or detects fire*/ kIfcSensorTypeEnum_FIRESENSOR, /** A device that senses or detects flow in a fluid.*/ kIfcSensorTypeEnum_FLOWSENSOR, /** A device that senses or detects gas concentration (other than CO2)*/ kIfcSensorTypeEnum_GASSENSOR, /** A device that senses or detects heat.*/ kIfcSensorTypeEnum_HEATSENSOR, /** A device that senses or detects humidity.*/ kIfcSensorTypeEnum_HUMIDITYSENSOR, /** A device that senses or detects light.*/ kIfcSensorTypeEnum_LIGHTSENSOR, /** A device that senses or detects moisture.*/ kIfcSensorTypeEnum_MOISTURESENSOR, /** A device that senses or detects movement.*/ kIfcSensorTypeEnum_MOVEMENTSENSOR, /** A device that senses or detects pressure.*/ kIfcSensorTypeEnum_PRESSURESENSOR, /** A device that senses or detects smoke.*/ kIfcSensorTypeEnum_SMOKESENSOR, /** A device that senses or detects sound.*/ kIfcSensorTypeEnum_SOUNDSENSOR, /** A device that senses or detects temperature.*/ kIfcSensorTypeEnum_TEMPERATURESENSOR, /** User-defined type.*/ kIfcSensorTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcSensorTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcSensorTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcSensorTypeEnum& getUnset() { static OdIfc2x3::IfcSensorTypeEnum nullEnum = OdIfc2x3::kIfcSensorTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcSequenceEnum& getUnset() { static OdIfc2x3::IfcSequenceEnum nullEnum = OdIfc2x3::kIfcSequenceEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details An IfcServiceLifeFactorTypeEnum is an enumerated list of the types of service life factor that can be applied and that modify the extent of the service life. */ enum IfcServiceLifeFactorTypeEnum { /** Adjustment of the service life resulting from the effect of the quality of components used.*/ kIfcServiceLifeFactorTypeEnum_A_QUALITYOFCOMPONENTS, /** Adjustment of the service life resulting from the effect of design level employed.*/ kIfcServiceLifeFactorTypeEnum_B_DESIGNLEVEL, /** Adjustment of the service life resulting from the effect of the quality of work executed.*/ kIfcServiceLifeFactorTypeEnum_C_WORKEXECUTIONLEVEL, /** Adjustment of the service life resulting from the effect of the indoor environment (where appropriate).*/ kIfcServiceLifeFactorTypeEnum_D_INDOORENVIRONMENT, /** Adjustment of the service life resulting from the effect of the outdoor environment (where appropriate).*/ kIfcServiceLifeFactorTypeEnum_E_OUTDOORENVIRONMENT, /** Adjustment of the service life resulting from the effect of the conditions in which components are operating.*/ kIfcServiceLifeFactorTypeEnum_F_INUSECONDITIONS, /** Adjustment of the service life resulting from the effect of the level or degree of maintenance applied to components.*/ kIfcServiceLifeFactorTypeEnum_G_MAINTENANCELEVEL, /** User-defined.*/ kIfcServiceLifeFactorTypeEnum_USERDEFINED, /** Not defined.*/ kIfcServiceLifeFactorTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcServiceLifeFactorTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcServiceLifeFactorTypeEnum& getUnset() { static OdIfc2x3::IfcServiceLifeFactorTypeEnum nullEnum = OdIfc2x3::kIfcServiceLifeFactorTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details An IfcServiceLifeTypeEnum is an enumerated list of the types of service life of an artifact. */ enum IfcServiceLifeTypeEnum { /** The service life that an asset has given.*/ kIfcServiceLifeTypeEnum_ACTUALSERVICELIFE, /** The service life that an artifact is expected to have under current operating conditions.*/ kIfcServiceLifeTypeEnum_EXPECTEDSERVICELIFE, /** The best or most optimistic estimate of service life that is quoted for an artifact under reference operating conditions.*/ kIfcServiceLifeTypeEnum_OPTIMISTICREFERENCESERVICELIFE, /** The least or most pessimistic estimate of service life that is quoted for an artifact under reference operating conditions.*/ kIfcServiceLifeTypeEnum_PESSIMISTICREFERENCESERVICELIFE, /** The typical service life that is quoted for an artifact under reference operating conditions.*/ kIfcServiceLifeTypeEnum_REFERENCESERVICELIFE, /** The value is unset.*/ kIfcServiceLifeTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcServiceLifeTypeEnum& getUnset() { static OdIfc2x3::IfcServiceLifeTypeEnum nullEnum = OdIfc2x3::kIfcServiceLifeTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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, /** The slab is used to represent a floor slab against the ground (and thereby being a part of the foundation). Another name is mat foundation.*/ kIfcSlabTypeEnum_BASESLAB, /** No description available.*/ kIfcSlabTypeEnum_USERDEFINED, /** No description available.*/ kIfcSlabTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcSlabTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcSlabTypeEnum& getUnset() { static OdIfc2x3::IfcSlabTypeEnum nullEnum = OdIfc2x3::kIfcSlabTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration defines the different sound scales. */ enum IfcSoundScaleEnum { /** Decibels in an A-weighted scale.*/ kIfcSoundScaleEnum_DBA, /** Decibels in an B-weighted scale.*/ kIfcSoundScaleEnum_DBB, /** Decibels in an C-weighted scale.*/ kIfcSoundScaleEnum_DBC, /** Noise criteria.*/ kIfcSoundScaleEnum_NC, /** Noise rating.*/ kIfcSoundScaleEnum_NR, /** User-defined.*/ kIfcSoundScaleEnum_USERDEFINED, /** Not defined.*/ kIfcSoundScaleEnum_NOTDEFINED, /** The value is unset.*/ kIfcSoundScaleEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcSoundScaleEnum& getUnset() { static OdIfc2x3::IfcSoundScaleEnum nullEnum = OdIfc2x3::kIfcSoundScaleEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details Enumeration defining the functional type of space heater. */ enum IfcSpaceHeaterTypeEnum { /** Sectional type radiator typically fabricated from welded sheet metal sections and resembling free standing cast-iron radiators.*/ kIfcSpaceHeaterTypeEnum_SECTIONALRADIATOR, /** Panel type radiator typically fabricated with flat panels, with or without an exposed extended fin surface attached to the rear for increased output.*/ kIfcSpaceHeaterTypeEnum_PANELRADIATOR, /** Tubular type radiator consisting of supply and return headers with interconnecting parallel tubes in a wide variety of lengths and heights.*/ kIfcSpaceHeaterTypeEnum_TUBULARRADIATOR, /** A heat-distributing unit that operates with gravity-circulated air.*/ kIfcSpaceHeaterTypeEnum_CONVECTOR, /** Baseboard heater designed for installation along the bottom of walls in place of the conventional baseboard.*/ kIfcSpaceHeaterTypeEnum_BASEBOARDHEATER, /** Fin-tube heater typically fabricated from metallic tubing, with metallic fins bonded to the tube.*/ kIfcSpaceHeaterTypeEnum_FINNEDTUBEUNIT, /** An assembly typically consisting of a fan, a motor, and a heating element.*/ kIfcSpaceHeaterTypeEnum_UNITHEATER, /** User-defined space heater type.*/ kIfcSpaceHeaterTypeEnum_USERDEFINED, /** Undefined space heater type.*/ kIfcSpaceHeaterTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcSpaceHeaterTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcSpaceHeaterTypeEnum& getUnset() { static OdIfc2x3::IfcSpaceHeaterTypeEnum nullEnum = OdIfc2x3::kIfcSpaceHeaterTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration defines the available generic types for IfcSpace and IfcSpaceType. */ enum IfcSpaceTypeEnum { /** No description available.*/ kIfcSpaceTypeEnum_USERDEFINED, /** No description available.*/ kIfcSpaceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcSpaceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcSpaceTypeEnum& getUnset() { static OdIfc2x3::IfcSpaceTypeEnum nullEnum = OdIfc2x3::kIfcSpaceTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details An IfcStackTerminalTypeEnum defines the range of different types of stack terminal that can be specified for use at the top of a vertical stack subsystem. */ enum IfcStackTerminalTypeEnum { /** Guard cage, typically wire mesh, at the top of the stack preventing access by birds.*/ kIfcStackTerminalTypeEnum_BIRDCAGE, /** A cowling placed at the top of a stack to eliminate downdraft.*/ kIfcStackTerminalTypeEnum_COWL, /** A box placed at the top of a rainwater downpipe to catch rainwater from guttering.*/ kIfcStackTerminalTypeEnum_RAINWATERHOPPER, /** User-defined type.*/ kIfcStackTerminalTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcStackTerminalTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcStackTerminalTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcStackTerminalTypeEnum& getUnset() { static OdIfc2x3::IfcStackTerminalTypeEnum nullEnum = OdIfc2x3::kIfcStackTerminalTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration defines the different types of stair flights that can further specify an IfcStairFlight or IfcStairFlightType. */ enum IfcStairFlightTypeEnum { /** A stair flight with a straight walking line.*/ kIfcStairFlightTypeEnum_STRAIGHT, /** A stair flight with a walking line including straight and curved sections.*/ kIfcStairFlightTypeEnum_WINDER, /** A stair flight with a circular or elliptic walking line.*/ kIfcStairFlightTypeEnum_SPIRAL, /** A stair flight with a curved walking line.*/ kIfcStairFlightTypeEnum_CURVED, /** A stair flight with a free form walking line (and outer boundaries).*/ kIfcStairFlightTypeEnum_FREEFORM, /** User-defined stair flight.*/ kIfcStairFlightTypeEnum_USERDEFINED, /** Undefined stair flight.*/ kIfcStairFlightTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcStairFlightTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcStairFlightTypeEnum& getUnset() { static OdIfc2x3::IfcStairFlightTypeEnum nullEnum = OdIfc2x3::kIfcStairFlightTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcStairTypeEnum& getUnset() { static OdIfc2x3::IfcStairTypeEnum nullEnum = OdIfc2x3::kIfcStairTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcStateEnum& getUnset() { static OdIfc2x3::IfcStateEnum nullEnum = OdIfc2x3::kIfcStateEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This type definition shall be used to distinguish between different types of structural 'curve' members, such as cables. The IfcStructuralCurveTypeEnum type is referenced by the entity IfcStructuralCurveMember. */ enum IfcStructuralCurveTypeEnum { /** RIGID_JOINED_MEMBER*/ kIfcStructuralCurveTypeEnum_RIGID_JOINED_MEMBER, /** PIN_JOINED_MEMBER*/ kIfcStructuralCurveTypeEnum_PIN_JOINED_MEMBER, /** CABLE*/ kIfcStructuralCurveTypeEnum_CABLE, /** TENSION_MEMBER*/ kIfcStructuralCurveTypeEnum_TENSION_MEMBER, /** COMPRESSION_MEMBER*/ kIfcStructuralCurveTypeEnum_COMPRESSION_MEMBER, /** User-defined.*/ kIfcStructuralCurveTypeEnum_USERDEFINED, /** Not defined.*/ kIfcStructuralCurveTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcStructuralCurveTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcStructuralCurveTypeEnum& getUnset() { static OdIfc2x3::IfcStructuralCurveTypeEnum nullEnum = OdIfc2x3::kIfcStructuralCurveTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This type definition shall be used to distinguish between different types of structural surface members, such as the typical mechanical function of walls, slabs and shells. */ enum IfcStructuralSurfaceTypeEnum { /** BENDING_ELEMENT*/ kIfcStructuralSurfaceTypeEnum_BENDING_ELEMENT, /** MEMBRANE_ELEMENT*/ kIfcStructuralSurfaceTypeEnum_MEMBRANE_ELEMENT, /** SHELL*/ kIfcStructuralSurfaceTypeEnum_SHELL, /** User-defined.*/ kIfcStructuralSurfaceTypeEnum_USERDEFINED, /** Not defined.*/ kIfcStructuralSurfaceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcStructuralSurfaceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcStructuralSurfaceTypeEnum& getUnset() { static OdIfc2x3::IfcStructuralSurfaceTypeEnum nullEnum = OdIfc2x3::kIfcStructuralSurfaceTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details IfcSurfaceSide is a denotion of whether negative, positive or both sides of a surface are being referenced. */ enum IfcSurfaceSide { /** The side of a surface which is in the same direction as the surface normal derived from the mathematical definition.*/ kIfcSurfaceSide_POSITIVE, /** The side of a surface which is in the opposite direction than the surface normal derived from the mathematical definition.*/ kIfcSurfaceSide_NEGATIVE, /** Both, positive and negative side.*/ kIfcSurfaceSide_BOTH, /** The value is unset.*/ kIfcSurfaceSide_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcSurfaceSide& getUnset() { static OdIfc2x3::IfcSurfaceSide nullEnum = OdIfc2x3::kIfcSurfaceSide_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcSurfaceTextureEnum defines the range of different types of image or pixel maps available. */ enum IfcSurfaceTextureEnum { kIfcSurfaceTextureEnum_BUMP, kIfcSurfaceTextureEnum_OPACITY, kIfcSurfaceTextureEnum_REFLECTION, kIfcSurfaceTextureEnum_SELFILLUMINATION, kIfcSurfaceTextureEnum_SHININESS, kIfcSurfaceTextureEnum_SPECULAR, kIfcSurfaceTextureEnum_TEXTURE, /** Shows where a transparent surface is more transparent. The opposite of opacity map.*/ kIfcSurfaceTextureEnum_TRANSPARENCYMAP, /** Not defined.*/ kIfcSurfaceTextureEnum_NOTDEFINED, /** The value is unset.*/ kIfcSurfaceTextureEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcSurfaceTextureEnum& getUnset() { static OdIfc2x3::IfcSurfaceTextureEnum nullEnum = OdIfc2x3::kIfcSurfaceTextureEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcSwitchingDeviceTypeEnum defines the range of different types of switch that can be specified. */ enum IfcSwitchingDeviceTypeEnum { /** An electrical device used to control the flow of power in a circuit on or off.*/ kIfcSwitchingDeviceTypeEnum_CONTACTOR, /** An emergency stop device acts to remove as quickly as possible any danger that may have arisen unexpectedly.*/ kIfcSwitchingDeviceTypeEnum_EMERGENCYSTOP, /** A starter is a switch which in the closed position controls the application of power to an electrical device.*/ kIfcSwitchingDeviceTypeEnum_STARTER, /** A switch disconnector is a switch which in the open position satisfies the isolating requirements specified for a disconnector.*/ kIfcSwitchingDeviceTypeEnum_SWITCHDISCONNECTOR, /** A toggle switch has two positions, and may enable or isolate electrical power or other setting (according to the switched port type).*/ kIfcSwitchingDeviceTypeEnum_TOGGLESWITCH, /** User-defined type.*/ kIfcSwitchingDeviceTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcSwitchingDeviceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcSwitchingDeviceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcSwitchingDeviceTypeEnum& getUnset() { static OdIfc2x3::IfcSwitchingDeviceTypeEnum nullEnum = OdIfc2x3::kIfcSwitchingDeviceTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details Enumeration defining the typical types of tanks. */ enum IfcTankTypeEnum { /** Tank is preformed.*/ kIfcTankTypeEnum_PREFORMED, kIfcTankTypeEnum_SECTIONAL, /** A closed container used in a closed fluid distribution system to mitigate the effects of thermal expansion or water hammer. The tank is typically constructed with a diaphragm dividing the tank into two sections, with fluid on one side of the diaphragm and air on the other. One example application is when connected to the primary circuit of a hot water system to accommodate the increase in volume of the water when it is heated.*/ kIfcTankTypeEnum_EXPANSION, /** A closed container used for storing fluids or gases at a pressure different from the ambient pressure. A pressure vessel is typically rated by an authority having jurisdiction for the operational pressure.*/ kIfcTankTypeEnum_PRESSUREVESSEL, /** User-defined tank type.*/ kIfcTankTypeEnum_USERDEFINED, /** Undefined tank type.*/ kIfcTankTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcTankTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcTankTypeEnum& getUnset() { static OdIfc2x3::IfcTankTypeEnum nullEnum = OdIfc2x3::kIfcTankTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details Enumeration defining the types of tendons. */ enum IfcTendonTypeEnum { /** The tendon is a strand.*/ kIfcTendonTypeEnum_STRAND, /** The tendon is a wire.*/ kIfcTendonTypeEnum_WIRE, /** The tendon is configured as a bar.*/ kIfcTendonTypeEnum_BAR, /** The tendon is coated.*/ kIfcTendonTypeEnum_COATED, /** The type of tendon is user defined.*/ kIfcTendonTypeEnum_USERDEFINED, /** The type of tendon is not defined.*/ kIfcTendonTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcTendonTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcTendonTypeEnum& getUnset() { static OdIfc2x3::IfcTendonTypeEnum nullEnum = OdIfc2x3::kIfcTendonTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The text path determines the direction of the text characters in respect to each other. */ enum IfcTextPath { /** Left*/ kIfcTextPath_LEFT, /** Right*/ kIfcTextPath_RIGHT, /** Up*/ kIfcTextPath_UP, /** Down*/ kIfcTextPath_DOWN, /** The value is unset.*/ kIfcTextPath_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcTextPath& getUnset() { static OdIfc2x3::IfcTextPath nullEnum = OdIfc2x3::kIfcTextPath_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration defines the various sources of thermal gains or losses for spaces or zones, derived from various use cases. */ enum IfcThermalLoadSourceEnum { /** Heat gains and losses from people.*/ kIfcThermalLoadSourceEnum_PEOPLE, /** Lighting loads.*/ kIfcThermalLoadSourceEnum_LIGHTING, kIfcThermalLoadSourceEnum_EQUIPMENT, /** Ventilation loads from indoor air.*/ kIfcThermalLoadSourceEnum_VENTILATIONINDOORAIR, /** Ventilation loads from outside air.*/ kIfcThermalLoadSourceEnum_VENTILATIONOUTSIDEAIR, /** Loads from recirculated air.*/ kIfcThermalLoadSourceEnum_RECIRCULATEDAIR, /** Loads from exhaust air.*/ kIfcThermalLoadSourceEnum_EXHAUSTAIR, /** Loads from the air exchange rate.*/ kIfcThermalLoadSourceEnum_AIREXCHANGERATE, /** Loads from the dry bulb temperature.*/ kIfcThermalLoadSourceEnum_DRYBULBTEMPERATURE, /** Loads from the relative humidity.*/ kIfcThermalLoadSourceEnum_RELATIVEHUMIDITY, kIfcThermalLoadSourceEnum_INFILTRATION, /** User-defined.*/ kIfcThermalLoadSourceEnum_USERDEFINED, /** Not defined.*/ kIfcThermalLoadSourceEnum_NOTDEFINED, /** The value is unset.*/ kIfcThermalLoadSourceEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcThermalLoadSourceEnum& getUnset() { static OdIfc2x3::IfcThermalLoadSourceEnum nullEnum = OdIfc2x3::kIfcThermalLoadSourceEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration defines the type of thermal load for spaces or zones, as derived from various use cases. */ enum IfcThermalLoadTypeEnum { /** Energy added or removed from air that affects its temperature.*/ kIfcThermalLoadTypeEnum_SENSIBLE, /** Energy added or removed from air that affects its humidity or concentration of water vapor.*/ kIfcThermalLoadTypeEnum_LATENT, /** Electromagnetic energy added or removed by emission or absorption.*/ kIfcThermalLoadTypeEnum_RADIANT, /** Undefined thermal load type.*/ kIfcThermalLoadTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcThermalLoadTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcThermalLoadTypeEnum& getUnset() { static OdIfc2x3::IfcThermalLoadTypeEnum nullEnum = OdIfc2x3::kIfcThermalLoadTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details IfcTimeSeriesDataTypeEnum describes a type of time series data and is used to determine a value during the time series which is not explicitly specified. */ enum IfcTimeSeriesDataTypeEnum { /** The time series data is continuous.*/ kIfcTimeSeriesDataTypeEnum_CONTINUOUS, /** The time series data is discrete.*/ kIfcTimeSeriesDataTypeEnum_DISCRETE, /** The time series data is discrete binary.*/ kIfcTimeSeriesDataTypeEnum_DISCRETEBINARY, /** The time series data is piecewise binary.*/ kIfcTimeSeriesDataTypeEnum_PIECEWISEBINARY, /** The time series data is piecewise constant.*/ kIfcTimeSeriesDataTypeEnum_PIECEWISECONSTANT, /** The time series data is piecewise continuous.*/ kIfcTimeSeriesDataTypeEnum_PIECEWISECONTINUOUS, /** The time series data is not defined.*/ kIfcTimeSeriesDataTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcTimeSeriesDataTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcTimeSeriesDataTypeEnum& getUnset() { static OdIfc2x3::IfcTimeSeriesDataTypeEnum nullEnum = OdIfc2x3::kIfcTimeSeriesDataTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details Defines the type of time series schedule, such as daily, weekly, monthly or annually. */ enum IfcTimeSeriesScheduleTypeEnum { /** An annual time series schedule.*/ kIfcTimeSeriesScheduleTypeEnum_ANNUAL, /** A monthly time series schedule.*/ kIfcTimeSeriesScheduleTypeEnum_MONTHLY, /** A weekly time series schedule.*/ kIfcTimeSeriesScheduleTypeEnum_WEEKLY, /** A daily time series schedule.*/ kIfcTimeSeriesScheduleTypeEnum_DAILY, /** A user-defined time series schedule type to be provided.*/ kIfcTimeSeriesScheduleTypeEnum_USERDEFINED, /** Not defined.*/ kIfcTimeSeriesScheduleTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcTimeSeriesScheduleTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcTimeSeriesScheduleTypeEnum& getUnset() { static OdIfc2x3::IfcTimeSeriesScheduleTypeEnum nullEnum = OdIfc2x3::kIfcTimeSeriesScheduleTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcTransformerTypeEnum defines the range of different types of transformer that can be specified. */ enum IfcTransformerTypeEnum { /** A transformer that changes the current between circuits.*/ kIfcTransformerTypeEnum_CURRENT, /** A transformer that changes the frequency between circuits.*/ kIfcTransformerTypeEnum_FREQUENCY, /** A transformer that changes the voltage between circuits.*/ kIfcTransformerTypeEnum_VOLTAGE, /** User-defined type.*/ kIfcTransformerTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcTransformerTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcTransformerTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcTransformerTypeEnum& getUnset() { static OdIfc2x3::IfcTransformerTypeEnum nullEnum = OdIfc2x3::kIfcTransformerTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcTransitionCode& getUnset() { static OdIfc2x3::IfcTransitionCode nullEnum = OdIfc2x3::kIfcTransitionCode_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcTransportElementTypeEnum& getUnset() { static OdIfc2x3::IfcTransportElementTypeEnum nullEnum = OdIfc2x3::kIfcTransportElementTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcTrimmingPreference& getUnset() { static OdIfc2x3::IfcTrimmingPreference nullEnum = OdIfc2x3::kIfcTrimmingPreference_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details Enumeration defining the typical types of tube bundles. */ enum IfcTubeBundleTypeEnum { /** Finned tube bundle type.*/ kIfcTubeBundleTypeEnum_FINNED, /** User-defined tube bundle type.*/ kIfcTubeBundleTypeEnum_USERDEFINED, /** Undefined tube bundle type.*/ kIfcTubeBundleTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcTubeBundleTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcTubeBundleTypeEnum& getUnset() { static OdIfc2x3::IfcTubeBundleTypeEnum nullEnum = OdIfc2x3::kIfcTubeBundleTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcUnitEnum& getUnset() { static OdIfc2x3::IfcUnitEnum nullEnum = OdIfc2x3::kIfcUnitEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details Enumeration defining the functional type of unitary equipment. */ enum IfcUnitaryEquipmentTypeEnum { /** A unitary air handling unit typically containing a fan, economizer, and coils.*/ kIfcUnitaryEquipmentTypeEnum_AIRHANDLER, /** A unitary packaged air-conditioning unit typically used in residential or light commercial applications.*/ kIfcUnitaryEquipmentTypeEnum_AIRCONDITIONINGUNIT, /** A system which separates the compressor from the evaporator, but acts as a unitary component typically within residential or light commercial applications.*/ kIfcUnitaryEquipmentTypeEnum_SPLITSYSTEM, /** A packaged assembly that is either field-erected or manufactured atop the roof of a large residential or commercial building and acts as a unitary component.*/ kIfcUnitaryEquipmentTypeEnum_ROOFTOPUNIT, /** User-defined unitary equipment type.*/ kIfcUnitaryEquipmentTypeEnum_USERDEFINED, /** Undefined unitary equipment type.*/ kIfcUnitaryEquipmentTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcUnitaryEquipmentTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcUnitaryEquipmentTypeEnum& getUnset() { static OdIfc2x3::IfcUnitaryEquipmentTypeEnum nullEnum = OdIfc2x3::kIfcUnitaryEquipmentTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcValveTypeEnum defines the range of different types of valve that can be specified. These are typically used in conjunction with Pset_ValveTypeCommon, which contains common properties for all valve types. */ enum IfcValveTypeEnum { /** Valve used to release air from a pipe or fitting.*/ kIfcValveTypeEnum_AIRRELEASE, /** Valve that opens to admit air if the pressure falls below atmospheric pressure.*/ kIfcValveTypeEnum_ANTIVACUUM, /** Valve that enables flow to be switched between pipelines (3 or 4 port).*/ kIfcValveTypeEnum_CHANGEOVER, /** Valve that permits water to flow in one direction only and is enclosed when there is no flow (2 port).*/ kIfcValveTypeEnum_CHECK, /** Valve used to facilitate commissioning of a system (2 port).*/ kIfcValveTypeEnum_COMMISSIONING, /** Valve that enables flow to be diverted from one branch of a pipeline to another (3 port).*/ kIfcValveTypeEnum_DIVERTING, /** A valve used to remove fluid from a piping system.*/ kIfcValveTypeEnum_DRAWOFFCOCK, /** An assembly that incorporates two valves used to prevent backflow.*/ kIfcValveTypeEnum_DOUBLECHECK, /** Valve used to facilitate regulation of fluid flow in a system.*/ kIfcValveTypeEnum_DOUBLEREGULATING, /** Faucet valve typically used as a flow discharge.*/ kIfcValveTypeEnum_FAUCET, /** Valve that flushes a predetermined quantity of water to cleanse a toilet, urinal, etc.*/ kIfcValveTypeEnum_FLUSHING, /** Valve that is used for controlling the flow of gas.*/ kIfcValveTypeEnum_GASCOCK, /** Gas tap typically used for venting or discharging gas from a system.*/ kIfcValveTypeEnum_GASTAP, /** Valve that closes off flow in a pipeline.*/ kIfcValveTypeEnum_ISOLATING, /** Valve that enables flow from two branches of a pipeline to be mixed together (3 port).*/ kIfcValveTypeEnum_MIXING, /** Valve that reduces the pressure of a fluid immediately downstream of its position in a pipeline to a preselected value or by a predetermined ratio.*/ kIfcValveTypeEnum_PRESSUREREDUCING, /** Spring or weight loaded valve that automatically discharges to a safe place fluid that has built up to excessive pressure in pipes or fittings.*/ kIfcValveTypeEnum_PRESSURERELIEF, /** Valve used to facilitate regulation of fluid flow in a system.*/ kIfcValveTypeEnum_REGULATING, /** Valve that closes under the action of a safety mechanism such as a drop weight, solenoid etc.*/ kIfcValveTypeEnum_SAFETYCUTOFF, /** Valve that restricts flow of steam while allowing condensate to pass through.*/ kIfcValveTypeEnum_STEAMTRAP, /** An isolating valve used on a domestic water service.*/ kIfcValveTypeEnum_STOPCOCK, /** User-defined valve type.*/ kIfcValveTypeEnum_USERDEFINED, /** Undefined valve type.*/ kIfcValveTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcValveTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcValveTypeEnum& getUnset() { static OdIfc2x3::IfcValveTypeEnum nullEnum = OdIfc2x3::kIfcValveTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details Enumeration defining the typical types of vibration isolators. */ enum IfcVibrationIsolatorTypeEnum { /** Compression type vibration isolator.*/ kIfcVibrationIsolatorTypeEnum_COMPRESSION, /** Spring type vibration isolator.*/ kIfcVibrationIsolatorTypeEnum_SPRING, /** User-defined vibration isolator type.*/ kIfcVibrationIsolatorTypeEnum_USERDEFINED, /** Undefined vibration isolator type.*/ kIfcVibrationIsolatorTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcVibrationIsolatorTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcVibrationIsolatorTypeEnum& getUnset() { static OdIfc2x3::IfcVibrationIsolatorTypeEnum nullEnum = OdIfc2x3::kIfcVibrationIsolatorTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details This enumeration defines the different types of walls that can further specify an IfcWall or IfcWallType. */ enum IfcWallTypeEnum { /** A standard wall, extruded vertically with a constant thickness along the wall path.*/ kIfcWallTypeEnum_STANDARD, /** A polygonal wall, extruded vertically, where the wall thickness varies along the wall path.*/ kIfcWallTypeEnum_POLYGONAL, /** A wall designed to withstand shear loads. Examples of shear wall are diaphragms inside a box girder, typically on a pier, to resist lateral forces and transfer them to the support.*/ kIfcWallTypeEnum_SHEAR, /** A stud wall framed with studs and faced with sheetings, sidings, wallboard, or plasterwork.*/ kIfcWallTypeEnum_ELEMENTEDWALL, /** A pier, or enclosure, or encasement, normally used to enclose plumbing in sanitary rooms. Such walls often do not extend to the ceiling.*/ kIfcWallTypeEnum_PLUMBINGWALL, /** User-defined wall element.*/ kIfcWallTypeEnum_USERDEFINED, /** Undefined wall element.*/ kIfcWallTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcWallTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcWallTypeEnum& getUnset() { static OdIfc2x3::IfcWallTypeEnum nullEnum = OdIfc2x3::kIfcWallTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \details The IfcWasteTerminalTypeEnum defines the range of different types of waste terminal that can be specified. */ enum IfcWasteTerminalTypeEnum { /** Pipe fitting, set into the floor, that retains liquid to prevent the passage of foul air*/ kIfcWasteTerminalTypeEnum_FLOORTRAP, /** Pipe fitting, set into the floor, that collects waste water and discharges it to a separate trap.*/ kIfcWasteTerminalTypeEnum_FLOORWASTE, /** Pipe fitting or assembly of fittings to receive surface water or waste water, fitted with a grating or sealed cover.*/ kIfcWasteTerminalTypeEnum_GULLYSUMP, kIfcWasteTerminalTypeEnum_GULLYTRAP, /** Chamber, on the line of a drain or discharge pipe, that prevents grease passing into a drainage system (BS6100 330 6205).*/ kIfcWasteTerminalTypeEnum_GREASEINTERCEPTOR, kIfcWasteTerminalTypeEnum_OILINTERCEPTOR, kIfcWasteTerminalTypeEnum_PETROLINTERCEPTOR, /** Pipe fitting, set into the roof, that collects rainwater for discharge into the rainwater system.*/ kIfcWasteTerminalTypeEnum_ROOFDRAIN, /** Electrically operated device that reduces kitchen or other waste into fragments small enough to be flushed into a drainage system.*/ kIfcWasteTerminalTypeEnum_WASTEDISPOSALUNIT, /** Pipe fitting, set adjacent to a sanitary terminal, that retains liquid to prevent the passage of foul air.*/ kIfcWasteTerminalTypeEnum_WASTETRAP, /** User-defined type.*/ kIfcWasteTerminalTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcWasteTerminalTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcWasteTerminalTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcWasteTerminalTypeEnum& getUnset() { static OdIfc2x3::IfcWasteTerminalTypeEnum nullEnum = OdIfc2x3::kIfcWasteTerminalTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcWindowPanelOperationEnum& getUnset() { static OdIfc2x3::IfcWindowPanelOperationEnum nullEnum = OdIfc2x3::kIfcWindowPanelOperationEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcWindowPanelPositionEnum& getUnset() { static OdIfc2x3::IfcWindowPanelPositionEnum nullEnum = OdIfc2x3::kIfcWindowPanelPositionEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcWindowStyleConstructionEnum& getUnset() { static OdIfc2x3::IfcWindowStyleConstructionEnum nullEnum = OdIfc2x3::kIfcWindowStyleConstructionEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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 OdIfc2x3::IfcWindowStyleOperationEnum& getUnset() { static OdIfc2x3::IfcWindowStyleOperationEnum nullEnum = OdIfc2x3::kIfcWindowStyleOperationEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { /** \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, /** User-defined.*/ kIfcWorkControlTypeEnum_USERDEFINED, /** Not defined.*/ kIfcWorkControlTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcWorkControlTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc2x3::IfcWorkControlTypeEnum& getUnset() { static OdIfc2x3::IfcWorkControlTypeEnum nullEnum = OdIfc2x3::kIfcWorkControlTypeEnum_unset; return nullEnum; } } } namespace OdIfc2x3 { } // namespace #include "TD_PackPop.h" #endif // _IFC2X3_ENUM_H