/////////////////////////////////////////////////////////////////////////////// // 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 _IFC4X2_ENUM_H #define _IFC4X2_ENUM_H #include "RxValue.h" #include "daiEnum.h" #include "Ifc4x2BuildOption.h" #include "TD_PackPush.h" namespace OdIfc4x2 { /** \details IfcActionRequestTypeEnum defines the types of sources through which a request can be made. */ enum IfcActionRequestTypeEnum { /** Request was made through email.*/ kIfcActionRequestTypeEnum_EMAIL, /** Request was made through facsimile.*/ kIfcActionRequestTypeEnum_FAX, /** Request was made verbally over a telephone.*/ kIfcActionRequestTypeEnum_PHONE, /** Request was made through postal mail.*/ kIfcActionRequestTypeEnum_POST, /** Request was made verbally in person.*/ kIfcActionRequestTypeEnum_VERBAL, /** User-defined type.*/ kIfcActionRequestTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcActionRequestTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcActionRequestTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcActionRequestTypeEnum& getUnset() { static OdIfc4x2::IfcActionRequestTypeEnum nullEnum = OdIfc4x2::kIfcActionRequestTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcActionSourceTypeEnum& getUnset() { static OdIfc4x2::IfcActionSourceTypeEnum nullEnum = OdIfc4x2::kIfcActionSourceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcActionTypeEnum& getUnset() { static OdIfc4x2::IfcActionTypeEnum nullEnum = OdIfc4x2::kIfcActionTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcActuatorTypeEnum& getUnset() { static OdIfc4x2::IfcActuatorTypeEnum nullEnum = OdIfc4x2::kIfcActuatorTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcAddressTypeEnum& getUnset() { static OdIfc4x2::IfcAddressTypeEnum nullEnum = OdIfc4x2::kIfcAddressTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcAirTerminalBoxTypeEnum& getUnset() { static OdIfc4x2::IfcAirTerminalBoxTypeEnum nullEnum = OdIfc4x2::kIfcAirTerminalBoxTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details Enumeration defining the functional types of air terminals. */ enum IfcAirTerminalTypeEnum { /** An outlet discharging supply air in various directions and planes.*/ kIfcAirTerminalTypeEnum_DIFFUSER, /** A covering for any area through which air passes.*/ kIfcAirTerminalTypeEnum_GRILLE, /** A rectilinear louvre.*/ kIfcAirTerminalTypeEnum_LOUVRE, /** A grille typically equipped with a damper or control valve.*/ kIfcAirTerminalTypeEnum_REGISTER, /** 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 OdIfc4x2::IfcAirTerminalTypeEnum& getUnset() { static OdIfc4x2::IfcAirTerminalTypeEnum nullEnum = OdIfc4x2::kIfcAirTerminalTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcAirToAirHeatRecoveryTypeEnum& getUnset() { static OdIfc4x2::IfcAirToAirHeatRecoveryTypeEnum nullEnum = OdIfc4x2::kIfcAirToAirHeatRecoveryTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcAlarmTypeEnum& getUnset() { static OdIfc4x2::IfcAlarmTypeEnum nullEnum = OdIfc4x2::kIfcAlarmTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration defines the different types of alignments. */ enum IfcAlignmentTypeEnum { /** No description available.*/ kIfcAlignmentTypeEnum_USERDEFINED, /** No description available.*/ kIfcAlignmentTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcAlignmentTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcAlignmentTypeEnum& getUnset() { static OdIfc4x2::IfcAlignmentTypeEnum nullEnum = OdIfc4x2::kIfcAlignmentTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcAnalysisModelTypeEnum& getUnset() { static OdIfc4x2::IfcAnalysisModelTypeEnum nullEnum = OdIfc4x2::kIfcAnalysisModelTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcAnalysisTheoryTypeEnum& getUnset() { static OdIfc4x2::IfcAnalysisTheoryTypeEnum nullEnum = OdIfc4x2::kIfcAnalysisTheoryTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcArithmeticOperatorEnum& getUnset() { static OdIfc4x2::IfcArithmeticOperatorEnum nullEnum = OdIfc4x2::kIfcArithmeticOperatorEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcAssemblyPlaceEnum& getUnset() { static OdIfc4x2::IfcAssemblyPlaceEnum nullEnum = OdIfc4x2::kIfcAssemblyPlaceEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details Defines the range of different types of audio-video devices that can be specified. */ enum IfcAudioVisualApplianceTypeEnum { /** A device that receives an audio signal and amplifies it to play through speakers.*/ kIfcAudioVisualApplianceTypeEnum_AMPLIFIER, /** A device that records images, either as a still photograph or as moving images known as videos or movies. Note that a camera may operate with light from the visible spectrum or from other parts of the electromagnetic spectrum such as infrared or ultraviolet.*/ kIfcAudioVisualApplianceTypeEnum_CAMERA, /** An electronic device that represents information in visual form such as a flat-panel display or television.*/ kIfcAudioVisualApplianceTypeEnum_DISPLAY, /** An acoustic-to-electric transducer or sensor that converts sound into an electrical signal. Microphones types in use include electromagnetic induction (dynamic microphones), capacitance change (condenser microphones) or piezoelectric generation to produce the signal from mechanical vibration.*/ kIfcAudioVisualApplianceTypeEnum_MICROPHONE, /** A device that plays audio and/or video content directly or to another device, having fixed or removable storage media.*/ kIfcAudioVisualApplianceTypeEnum_PLAYER, /** An apparatus for projecting a picture on a screen. Whether the device is an overhead, slide projector, or a film projector, it is usually referred to as simply a projector.*/ kIfcAudioVisualApplianceTypeEnum_PROJECTOR, /** A device that receives audio and/or video signals, switches sources, and amplifies signals to play through speakers.*/ kIfcAudioVisualApplianceTypeEnum_RECEIVER, /** A loudspeaker, speaker, or speaker system is an electroacoustical transducer that converts an electrical signal to sound.*/ kIfcAudioVisualApplianceTypeEnum_SPEAKER, /** A device that receives audio and/or video signals, switches sources, and transmits signals to downstream devices.*/ kIfcAudioVisualApplianceTypeEnum_SWITCHER, /** A telecommunications device that is used to transmit and receive sound, and optionally video.*/ kIfcAudioVisualApplianceTypeEnum_TELEPHONE, /** An electronic receiver that detects, demodulates, and amplifies transmitted signals.*/ kIfcAudioVisualApplianceTypeEnum_TUNER, /** User-defined type.*/ kIfcAudioVisualApplianceTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcAudioVisualApplianceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcAudioVisualApplianceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcAudioVisualApplianceTypeEnum& getUnset() { static OdIfc4x2::IfcAudioVisualApplianceTypeEnum nullEnum = OdIfc4x2::kIfcAudioVisualApplianceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcBSplineCurveForm& getUnset() { static OdIfc4x2::IfcBSplineCurveForm nullEnum = OdIfc4x2::kIfcBSplineCurveForm_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details The IfcBSplineSurfaceForm represents a part of a surface of some specific form. */ enum IfcBSplineSurfaceForm { /** A bounded portion of a plane represented by a B-spline surface of degree 1 in each parameter.*/ kIfcBSplineSurfaceForm_PLANE_SURF, /** A bounded portion of a cylindrical surface.*/ kIfcBSplineSurfaceForm_CYLINDRICAL_SURF, /** A bounded portion of the surface of a right circular cone.*/ kIfcBSplineSurfaceForm_CONICAL_SURF, /** A bounded portion of a sphere, or a complete sphere, represented by a B-spline surface.*/ kIfcBSplineSurfaceForm_SPHERICAL_SURF, /** A torus, or portion of a torus, represented by a B-spline surface.*/ kIfcBSplineSurfaceForm_TOROIDAL_SURF, /** A bounded portion of a surface of revolution.*/ kIfcBSplineSurfaceForm_SURF_OF_REVOLUTION, /** A surface constructed from two parametric curves by joining with straight lines corresponding points with the same parameter value on each of the curves.*/ kIfcBSplineSurfaceForm_RULED_SURF, /** A special case of a ruled surface in which the second curve degenerates to a single point; when represented by a B-spline surface all the control points along one edge will be coincident.*/ kIfcBSplineSurfaceForm_GENERALISED_CONE, /** A bounded portion of one of the class of surfaces of degree 2 in the variables x, y and z.*/ kIfcBSplineSurfaceForm_QUADRIC_SURF, /** A bounded portion of a surface of linear extrusion represented by a B-spline surface of degree 1 in one of the parameters.*/ kIfcBSplineSurfaceForm_SURF_OF_LINEAR_EXTRUSION, /** A surface for which no particular form is specified.*/ kIfcBSplineSurfaceForm_UNSPECIFIED, /** The value is unset.*/ kIfcBSplineSurfaceForm_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcBSplineSurfaceForm& getUnset() { static OdIfc4x2::IfcBSplineSurfaceForm nullEnum = OdIfc4x2::kIfcBSplineSurfaceForm_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 wide often prestressed beam with a hollow-core profile that usually serves as a slab component.*/ kIfcBeamTypeEnum_HOLLOWCORE, /** A beam or horizontal piece of material over an opening (e.g. door, window).*/ kIfcBeamTypeEnum_LINTEL, /** A tall beam placed on the facade of a building. One tall side is usually finished to provide the exterior of the building. Can be used to support joists or slab elements on its interior side.*/ kIfcBeamTypeEnum_SPANDREL, /** 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, /** A segment of a girder (e.g. each span of a continuous girder).*/ kIfcBeamTypeEnum_GIRDER_SEGMENT, /** End portion of a girder transmitting loads to supports and providing moment resistance to adjoining segment.*/ kIfcBeamTypeEnum_DIAPHRAGM, /** A transversal beam on top of a pier (on a single column or extending from one column of a pier to another column of the same pier).*/ kIfcBeamTypeEnum_PIERCAP, /** A beam on top of a retaining wall or a wing wall, preventing earth movement.*/ kIfcBeamTypeEnum_HATSTONE, /** A non-loadbearing beam on the longitudinal edge of bridge slab, usually encasing installations.*/ kIfcBeamTypeEnum_CORNICE, /** A beam on the longitudinal edge of bridge slab, usually concrete, providing additional stiffening and protection from the elements.*/ kIfcBeamTypeEnum_EDGEBEAM, /** 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 OdIfc4x2::IfcBeamTypeEnum& getUnset() { static OdIfc4x2::IfcBeamTypeEnum nullEnum = OdIfc4x2::kIfcBeamTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details Enumeration of Bearing Displacement Types. */ enum IfcBearingTypeDisplacementEnum { /** No movement allowed.*/ kIfcBearingTypeDisplacementEnum_FIXED_MOVEMENT, /** The transverse direction is fixed. Only axial movement is allowed.*/ kIfcBearingTypeDisplacementEnum_GUIDED_LONGITUDINAL, /** The axial direction is fixed. Only transverse movement is allowed.*/ kIfcBearingTypeDisplacementEnum_GUIDED_TRANSVERSAL, /** All horizontal movement allowed.*/ kIfcBearingTypeDisplacementEnum_FREE_MOVEMENT, /** Not defined.*/ kIfcBearingTypeDisplacementEnum_NOTDEFINED, /** The value is unset.*/ kIfcBearingTypeDisplacementEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcBearingTypeDisplacementEnum& getUnset() { static OdIfc4x2::IfcBearingTypeDisplacementEnum nullEnum = OdIfc4x2::kIfcBearingTypeDisplacementEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details Enumeration of Bearing Types. */ enum IfcBearingTypeEnum { /** The bearing functionality is provided by cylinder in a concave cylinder.*/ kIfcBearingTypeEnum_CYLINDRICAL, /** The bearing functionality is provided by convex dome in a concave basin.*/ kIfcBearingTypeEnum_SPHERICAL, /** A pad bearing which carries vertical load by contact stresses between a sheet of sliding material and a mating surface that permits movements by sliding and accommodates rotation by deformation of the elastomer.*/ kIfcBearingTypeEnum_ELASTOMERIC, /** A bearing which carries vertical load by compression of an (elastomeric) disc confined in a (steel) cylinder and which accommodates rotations by deformations of the disc.*/ kIfcBearingTypeEnum_POT, /** A bearing that ensures that the structure maintains the correct location or expansion/contraction path and takes no vertical load. Includes also restraint bearings.*/ kIfcBearingTypeEnum_GUIDE, /** The bearing functionality is provided by a rocker construction. Includes line rocker and point rocker bearings.*/ kIfcBearingTypeEnum_ROCKER, /** The bearing functionality is provided by one or more rollers that are placed between two plates.*/ kIfcBearingTypeEnum_ROLLER, /** A disk bearing consist of an elastomeric disc between two metal plates.*/ kIfcBearingTypeEnum_DISK, /** User-defined bearing element.*/ kIfcBearingTypeEnum_USERDEFINED, /** Undefined bearing element.*/ kIfcBearingTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcBearingTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcBearingTypeEnum& getUnset() { static OdIfc4x2::IfcBearingTypeEnum nullEnum = OdIfc4x2::kIfcBearingTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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, /** Identifies that an aggregation (set, list or table) must include the value (individual item) set by the constraint.*/ kIfcBenchmarkEnum_INCLUDES, /** Identifies that an aggregation (set, list or table) must not include the value (individual item) set by the constraint.*/ kIfcBenchmarkEnum_NOTINCLUDES, /** Identifies that a value (individual item) must be included in the aggregation (set, list or table) set by the constraint.*/ kIfcBenchmarkEnum_INCLUDEDIN, /** Identifies that a value (individual item) must not be included in the aggregation (set, list or table) set by the constraint.*/ kIfcBenchmarkEnum_NOTINCLUDEDIN, /** The value is unset.*/ kIfcBenchmarkEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcBenchmarkEnum& getUnset() { static OdIfc4x2::IfcBenchmarkEnum nullEnum = OdIfc4x2::kIfcBenchmarkEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcBoilerTypeEnum& getUnset() { static OdIfc4x2::IfcBoilerTypeEnum nullEnum = OdIfc4x2::kIfcBoilerTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcBooleanOperator& getUnset() { static OdIfc4x2::IfcBooleanOperator nullEnum = OdIfc4x2::kIfcBooleanOperator_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details Enumerations of IfcBridge parts. */ enum IfcBridgePartTypeEnum { /** The substructures at the ends of a bridge, supporting its superstructure. They may be composed of wing walls (on each side), head wall, stem wall, and cone*/ kIfcBridgePartTypeEnum_ABUTMENT, /** A bridge deck is comprised of those elements used for conveying traffic but does not perform structural functions of the superstructure*/ kIfcBridgePartTypeEnum_DECK, /** A segment of the bridge deck. Segments may be separated by construction or expansion joints*/ kIfcBridgePartTypeEnum_DECK_SEGMENT, /** The structural elements that support and anchor the bridge to the ground, transmitting all loads to the supporting strata*/ kIfcBridgePartTypeEnum_FOUNDATION, /** A bridge pier is a type of structure that extends to the ground below or into the water. It is used to support bridge superstructure and transfer the loads to the foundation.*/ kIfcBridgePartTypeEnum_PIER, /** A segment of the bridge pier. Segments may be separated by construction or expansion joints*/ kIfcBridgePartTypeEnum_PIER_SEGMENT, /** A vertical structure supporting cables in suspended or stayed structures*/ kIfcBridgePartTypeEnum_PYLON, /** The elements that transfer loads to the ground. It includes abutments and piers*/ kIfcBridgePartTypeEnum_SUBSTRUCTURE, /** The part of the bridge that span horizontally and transfers the traffic load to the bridge substructures*/ kIfcBridgePartTypeEnum_SUPERSTRUCTURE, /** No description available.*/ kIfcBridgePartTypeEnum_SURFACESTRUCTURE, /** User defined*/ kIfcBridgePartTypeEnum_USERDEFINED, /** Not defined*/ kIfcBridgePartTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcBridgePartTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcBridgePartTypeEnum& getUnset() { static OdIfc4x2::IfcBridgePartTypeEnum nullEnum = OdIfc4x2::kIfcBridgePartTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details Definitions from ISO 6707 */ enum IfcBridgeTypeEnum { /** ISO 6707: Bridge that has one or more arches as its main structure.*/ kIfcBridgeTypeEnum_ARCHED, /** ISO 6707: Bridge with one or more towers and inclined cables that are connected to the top or the shaft of the tower and support the deck.*/ kIfcBridgeTypeEnum_CABLE_STAYED, /** ISO 6707: Bridge, the main structural members of which are cantilevers.*/ kIfcBridgeTypeEnum_CANTILEVER, /** ISO 6707: Transverse drain or waterway construction under a road, railway, or canal, or through an embankment, in the form of a large pipe or enclosed channel.*/ kIfcBridgeTypeEnum_CULVERT, /** Framework bridge.*/ kIfcBridgeTypeEnum_FRAMEWORK, /** A bridge that uses girders as the means of supporting its deck.*/ kIfcBridgeTypeEnum_GIRDER, /** ISO 6707: Bridge, the main structural members of which are catenary cables from which the deck is suspended.*/ kIfcBridgeTypeEnum_SUSPENSION, /** ISO 6707: Bridge with braced triangulated frame designed to act as a beam.*/ kIfcBridgeTypeEnum_TRUSS, /** User defined bridge.*/ kIfcBridgeTypeEnum_USERDEFINED, /** Undefined bridge.*/ kIfcBridgeTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcBridgeTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcBridgeTypeEnum& getUnset() { static OdIfc4x2::IfcBridgeTypeEnum nullEnum = OdIfc4x2::kIfcBridgeTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration defines the different types of building element parts. */ enum IfcBuildingElementPartTypeEnum { /** The part provides thermal insulation, for example as insulation layer between wall panels in sandwich walls or as infill in stud walls.*/ kIfcBuildingElementPartTypeEnum_INSULATION, /** The part is a precast panel, usually as an internal or external layer in a sandwich wall panel.*/ kIfcBuildingElementPartTypeEnum_PRECASTPANEL, /** A form of scour protection consisting of timber, concrete, riprap, paving, or other construction placed adjacent to abutments and piers to prevent undermining.*/ kIfcBuildingElementPartTypeEnum_APRON, /** User-defined accessory.*/ kIfcBuildingElementPartTypeEnum_USERDEFINED, /** Undefined accessory.*/ kIfcBuildingElementPartTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcBuildingElementPartTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcBuildingElementPartTypeEnum& getUnset() { static OdIfc4x2::IfcBuildingElementPartTypeEnum nullEnum = OdIfc4x2::kIfcBuildingElementPartTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration defines the available generic types for IfcBuildingElementProxy or IfcBuildingElementProxyType. */ enum IfcBuildingElementProxyTypeEnum { /** Not used - kept for upward compatibility.*/ kIfcBuildingElementProxyTypeEnum_COMPLEX, /** Not used - kept for upward compatibility.*/ kIfcBuildingElementProxyTypeEnum_ELEMENT, /** Not used - kept for upward compatibility.*/ kIfcBuildingElementProxyTypeEnum_PARTIAL, /** The proxy denotes a provision for voids (a proposed opening not applied as void yet).*/ kIfcBuildingElementProxyTypeEnum_PROVISIONFORVOID, /** The proxy denotes a provision for space (e.g. the space allocated as a provision for mechanical equipment or furniture).*/ kIfcBuildingElementProxyTypeEnum_PROVISIONFORSPACE, /** 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 OdIfc4x2::IfcBuildingElementProxyTypeEnum& getUnset() { static OdIfc4x2::IfcBuildingElementProxyTypeEnum nullEnum = OdIfc4x2::kIfcBuildingElementProxyTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration identifies different types of building systems. */ enum IfcBuildingSystemTypeEnum { /** System of doors, windows, and other fillings in openings in a built envelope that are designed to permit the passage of air or light.*/ kIfcBuildingSystemTypeEnum_FENESTRATION, /** System of shallow and deep foundation elements that transmit forces to the supporting ground.*/ kIfcBuildingSystemTypeEnum_FOUNDATION, /** System of built elements that transmit forces and stiffen the construction.*/ kIfcBuildingSystemTypeEnum_LOADBEARING, /** System of built elements that provide the outer skin to protect the construction (such as the facade).*/ kIfcBuildingSystemTypeEnum_OUTERSHELL, /** System of shading elements (external or internal) that permits the limitation or control of impact of natural sun light.*/ kIfcBuildingSystemTypeEnum_SHADING, /** System of all transport elements in a building that enables the transport of people or goods.*/ kIfcBuildingSystemTypeEnum_TRANSPORT, kIfcBuildingSystemTypeEnum_REINFORCING, /** System of elements providing pre-stressing to the structure, including typically manufactured products such as tendons, anchorages (active, dead, coupling), ducts, vents and deviators, and in-situ concrete segments, tendon spacers, blisters and additional reinforcements.*/ kIfcBuildingSystemTypeEnum_PRESTRESSING, /** No description available.*/ kIfcBuildingSystemTypeEnum_USERDEFINED, /** No description available.*/ kIfcBuildingSystemTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcBuildingSystemTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcBuildingSystemTypeEnum& getUnset() { static OdIfc4x2::IfcBuildingSystemTypeEnum nullEnum = OdIfc4x2::kIfcBuildingSystemTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details Enumeration defining the functional type of burner. */ enum IfcBurnerTypeEnum { /** User-defined burner type.*/ kIfcBurnerTypeEnum_USERDEFINED, /** Undefined burner type.*/ kIfcBurnerTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcBurnerTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcBurnerTypeEnum& getUnset() { static OdIfc4x2::IfcBurnerTypeEnum nullEnum = OdIfc4x2::kIfcBurnerTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcCableCarrierFittingTypeEnum& getUnset() { static OdIfc4x2::IfcCableCarrierFittingTypeEnum nullEnum = OdIfc4x2::kIfcCableCarrierFittingTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcCableCarrierSegmentTypeEnum& getUnset() { static OdIfc4x2::IfcCableCarrierSegmentTypeEnum nullEnum = OdIfc4x2::kIfcCableCarrierSegmentTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details The IfcCableFittingTypeEnum defines the range of different types of cable fitting that can be specified. */ enum IfcCableFittingTypeEnum { /** A fitting that joins two cable segments of the same connector type (though potentially different gender).*/ kIfcCableFittingTypeEnum_CONNECTOR, /** A fitting that begins a cable segment at a non-electrical element such as a grounding clamp attached to a pipe.*/ kIfcCableFittingTypeEnum_ENTRY, /** A fitting that ends a cable segment at a non-electrical element such as a grounding clamp attached to a pipe or to the ground.*/ kIfcCableFittingTypeEnum_EXIT, /** A fitting that joins three or more segments of arbitrary connector types for signal splitting or multiplexing.*/ kIfcCableFittingTypeEnum_JUNCTION, /** A fitting that joins two cable segments of different connector types.*/ kIfcCableFittingTypeEnum_TRANSITION, /** User-defined type.*/ kIfcCableFittingTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcCableFittingTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcCableFittingTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcCableFittingTypeEnum& getUnset() { static OdIfc4x2::IfcCableFittingTypeEnum nullEnum = OdIfc4x2::kIfcCableFittingTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details The IfcCableSegmentTypeEnum defines the range of different types of cable segment that can be specified. */ enum IfcCableSegmentTypeEnum { /** Electrical conductor that makes a common connection between several electrical circuits. Properties of a busbar are the same as those of a cable segment and are captured by the cable segment property set.*/ kIfcCableSegmentTypeEnum_BUSBARSEGMENT, /** 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, /** A self contained element of a cable that comprises one or more conductors and sheathing.The core of one lead is normally single wired or multiwired which are intertwined.*/ kIfcCableSegmentTypeEnum_CORESEGMENT, /** User-defined type.*/ kIfcCableSegmentTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcCableSegmentTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcCableSegmentTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcCableSegmentTypeEnum& getUnset() { static OdIfc4x2::IfcCableSegmentTypeEnum nullEnum = OdIfc4x2::kIfcCableSegmentTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details Enumeration of Caisson Foundation Types. */ enum IfcCaissonFoundationTypeEnum { /** Open box.*/ kIfcCaissonFoundationTypeEnum_WELL, /** Closed box.*/ kIfcCaissonFoundationTypeEnum_CAISSON, /** User-defined caisson foundation element.*/ kIfcCaissonFoundationTypeEnum_USERDEFINED, /** Undefined caisson element.*/ kIfcCaissonFoundationTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcCaissonFoundationTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcCaissonFoundationTypeEnum& getUnset() { static OdIfc4x2::IfcCaissonFoundationTypeEnum nullEnum = OdIfc4x2::kIfcCaissonFoundationTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 change action is not known or has not been defined.*/ kIfcChangeActionEnum_NOTDEFINED, /** The value is unset.*/ kIfcChangeActionEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcChangeActionEnum& getUnset() { static OdIfc4x2::IfcChangeActionEnum nullEnum = OdIfc4x2::kIfcChangeActionEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcChillerTypeEnum& getUnset() { static OdIfc4x2::IfcChillerTypeEnum nullEnum = OdIfc4x2::kIfcChillerTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration defines the valid types of chimneys that can be predefined using the enumeration values. */ enum IfcChimneyTypeEnum { /** No description available.*/ kIfcChimneyTypeEnum_USERDEFINED, /** No description available.*/ kIfcChimneyTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcChimneyTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcChimneyTypeEnum& getUnset() { static OdIfc4x2::IfcChimneyTypeEnum nullEnum = OdIfc4x2::kIfcChimneyTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details Enumeration defining the typical types of coils. */ enum IfcCoilTypeEnum { /** Cooling coil using a refrigerant to cool the air stream directly.*/ kIfcCoilTypeEnum_DXCOOLINGCOIL, /** Heating coil using electricity as a heating source.*/ kIfcCoilTypeEnum_ELECTRICHEATINGCOIL, /** Heating coil using gas as a heating source.*/ kIfcCoilTypeEnum_GASHEATINGCOIL, /** Cooling or Heating coil that uses a hydronic fluid as a cooling or heating source.*/ kIfcCoilTypeEnum_HYDRONICCOIL, /** Heating coil using steam as heating source.*/ kIfcCoilTypeEnum_STEAMHEATINGCOIL, /** Cooling coil using chilled water. HYDRONICCOIL supercedes this enumerator.*/ kIfcCoilTypeEnum_WATERCOOLINGCOIL, /** Heating coil using hot water as a heating source. HYDRONICCOIL supercedes this enumerator.*/ kIfcCoilTypeEnum_WATERHEATINGCOIL, /** User-defined coil type.*/ kIfcCoilTypeEnum_USERDEFINED, /** Undefined coil type.*/ kIfcCoilTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcCoilTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcCoilTypeEnum& getUnset() { static OdIfc4x2::IfcCoilTypeEnum nullEnum = OdIfc4x2::kIfcCoilTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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, /** A column element embedded within a wall that can be required to be load bearing but may also only be used for decorative purposes.*/ kIfcColumnTypeEnum_PILASTER, /** An individual vertical part of a pier, may be a simple column, i.e. no breakdown into segments or separate structural parts such as flanges and web(s), or may be an aggregation of segments and/or parts.*/ kIfcColumnTypeEnum_PIERSTEM, /** A vertical segment of a pier column.*/ kIfcColumnTypeEnum_PIERSTEM_SEGMENT, /** A column transmitting vertical loads from a superstructure to an arch below it.*/ kIfcColumnTypeEnum_STANDCOLUMN, /** User-defined linear element.*/ kIfcColumnTypeEnum_USERDEFINED, /** Undefined linear element.*/ kIfcColumnTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcColumnTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcColumnTypeEnum& getUnset() { static OdIfc4x2::IfcColumnTypeEnum nullEnum = OdIfc4x2::kIfcColumnTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details Defines the range of different types of communications appliance that can be specified. */ enum IfcCommunicationsApplianceTypeEnum { /** A transducer designed to transmit or receive electromagnetic waves.*/ kIfcCommunicationsApplianceTypeEnum_ANTENNA, /** A desktop, laptop, tablet, or other type of computer that can be moved from one place to another and connected to an electrical supply via a plugged outlet.*/ kIfcCommunicationsApplianceTypeEnum_COMPUTER, /** A machine that has the primary function of transmitting a facsimile copy of printed matter using a telephone line.*/ kIfcCommunicationsApplianceTypeEnum_FAX, /** A gateway connects multiple network segments with different protocols at all layers (layers 1-7) of the Open Systems Interconnection (OSI) model.*/ kIfcCommunicationsApplianceTypeEnum_GATEWAY, /** A modem (from modulator-demodulator) is a device that modulates an analog carrier signal to encode digital information, and also demodulates such a carrier signal to decode the transmitted information.*/ kIfcCommunicationsApplianceTypeEnum_MODEM, /** A network appliance performs a dedicated function such as firewall protection, content filtering, load balancing, or equipment management.*/ kIfcCommunicationsApplianceTypeEnum_NETWORKAPPLIANCE, /** A network bridge connects multiple network segments at the data link layer (layer 2) of the OSI model, and the term layer 2 switch is very often used interchangeably with bridge.*/ kIfcCommunicationsApplianceTypeEnum_NETWORKBRIDGE, /** A network hub connects multiple network segments at the physical layer (layer 1) of the OSI model.*/ kIfcCommunicationsApplianceTypeEnum_NETWORKHUB, /** A machine that has the primary function of printing text and/or graphics onto paper or other media.*/ kIfcCommunicationsApplianceTypeEnum_PRINTER, /** A repeater is an electronic device that receives a signal and retransmits it at a higher level and/or higher power, or onto the other side of an obstruction, so that the signal can cover longer distances without degradation.*/ kIfcCommunicationsApplianceTypeEnum_REPEATER, /** A router is a networking device whose software and hardware are usually tailored to the tasks of routing and forwarding information. For example, on the Internet, information is directed to various paths by routers.*/ kIfcCommunicationsApplianceTypeEnum_ROUTER, /** A machine that has the primary function of scanning the content of printed matter and converting it to digital format that can be stored in a computer.*/ kIfcCommunicationsApplianceTypeEnum_SCANNER, /** User-defined type.*/ kIfcCommunicationsApplianceTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcCommunicationsApplianceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcCommunicationsApplianceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcCommunicationsApplianceTypeEnum& getUnset() { static OdIfc4x2::IfcCommunicationsApplianceTypeEnum nullEnum = OdIfc4x2::kIfcCommunicationsApplianceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration defines the applicable subtype of instances of IfcComplexProperty or IfcPhysicalComplexQuantity that may be created and defined by an IfcComplexPropertyTemplate. */ enum IfcComplexPropertyTemplateTypeEnum { /** The properties defined by this IfcComplexPropertyTemplate are of type IfcComplexProperty.*/ kIfcComplexPropertyTemplateTypeEnum_P_COMPLEX, /** The quantities defined by this IfcComplexPropertyTemplate are of type IfcPhysicalComplexQuantity.*/ kIfcComplexPropertyTemplateTypeEnum_Q_COMPLEX, /** The value is unset.*/ kIfcComplexPropertyTemplateTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcComplexPropertyTemplateTypeEnum& getUnset() { static OdIfc4x2::IfcComplexPropertyTemplateTypeEnum nullEnum = OdIfc4x2::kIfcComplexPropertyTemplateTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcCompressorTypeEnum& getUnset() { static OdIfc4x2::IfcCompressorTypeEnum nullEnum = OdIfc4x2::kIfcCompressorTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 { /** A condenser in which heat is transferred to an air-stream.*/ kIfcCondenserTypeEnum_AIRCOOLED, /** A condenser that is cooled evaporatively.*/ kIfcCondenserTypeEnum_EVAPORATIVECOOLED, /** Water-cooled condenser with unspecified operation.*/ kIfcCondenserTypeEnum_WATERCOOLED, /** Water-cooled condenser with plates brazed together to form an assembly of separate channels.*/ kIfcCondenserTypeEnum_WATERCOOLEDBRAZEDPLATE, /** Water-cooled condenser with cooling water circulated through one or more continuous or assembled coils contained within the shell.*/ kIfcCondenserTypeEnum_WATERCOOLEDSHELLCOIL, /** Water-cooled condenser with cooling water circulated through one or more tubes contained within the shell.*/ kIfcCondenserTypeEnum_WATERCOOLEDSHELLTUBE, /** Water-cooled condenser consisting of one or more assemblies of two tubes, one within the other.*/ kIfcCondenserTypeEnum_WATERCOOLEDTUBEINTUBE, /** User-defined condenser type.*/ kIfcCondenserTypeEnum_USERDEFINED, /** Undefined condenser type.*/ kIfcCondenserTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcCondenserTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcCondenserTypeEnum& getUnset() { static OdIfc4x2::IfcCondenserTypeEnum nullEnum = OdIfc4x2::kIfcCondenserTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcConnectionTypeEnum& getUnset() { static OdIfc4x2::IfcConnectionTypeEnum nullEnum = OdIfc4x2::kIfcConnectionTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcConstraintEnum& getUnset() { static OdIfc4x2::IfcConstraintEnum nullEnum = OdIfc4x2::kIfcConstraintEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration is used to identify the primary purpose of a construction equipment resource. It is limited to the most common equipment used in construction. */ enum IfcConstructionEquipmentResourceTypeEnum { /** Removal or destruction of building elements.*/ kIfcConstructionEquipmentResourceTypeEnum_DEMOLISHING, /** Excavating, filling, or contouring earth.*/ kIfcConstructionEquipmentResourceTypeEnum_EARTHMOVING, /** Lifting, positioning, and placing elements.*/ kIfcConstructionEquipmentResourceTypeEnum_ERECTING, /** Temporary heat to support construction.*/ kIfcConstructionEquipmentResourceTypeEnum_HEATING, /** Temporary lighting to support construction.*/ kIfcConstructionEquipmentResourceTypeEnum_LIGHTING, /** Roads or walkways such as asphalt or concrete.*/ kIfcConstructionEquipmentResourceTypeEnum_PAVING, /** Installing materials through pumps.*/ kIfcConstructionEquipmentResourceTypeEnum_PUMPING, /** Transporting products or materials.*/ kIfcConstructionEquipmentResourceTypeEnum_TRANSPORTING, /** User-defined resource.*/ kIfcConstructionEquipmentResourceTypeEnum_USERDEFINED, /** Undefined resource.*/ kIfcConstructionEquipmentResourceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcConstructionEquipmentResourceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcConstructionEquipmentResourceTypeEnum& getUnset() { static OdIfc4x2::IfcConstructionEquipmentResourceTypeEnum nullEnum = OdIfc4x2::kIfcConstructionEquipmentResourceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration is used to identify the primary purpose of a construction material resource. It is limited to the most common raw materials used in construction and excludes materials commonly sold as finished products. */ enum IfcConstructionMaterialResourceTypeEnum { /** Construction aggregate including sand, gravel, and crushed stone.*/ kIfcConstructionMaterialResourceTypeEnum_AGGREGATES, /** Cast-in-place concrete.*/ kIfcConstructionMaterialResourceTypeEnum_CONCRETE, /** Wall board, including gypsum board.*/ kIfcConstructionMaterialResourceTypeEnum_DRYWALL, /** Fuel for running equipment.*/ kIfcConstructionMaterialResourceTypeEnum_FUEL, /** Any gypsum material.*/ kIfcConstructionMaterialResourceTypeEnum_GYPSUM, /** Masonry including brick, stone, concrete block, glass block, and tile.*/ kIfcConstructionMaterialResourceTypeEnum_MASONRY, /** Any metallic material.*/ kIfcConstructionMaterialResourceTypeEnum_METAL, /** Any plastic material.*/ kIfcConstructionMaterialResourceTypeEnum_PLASTIC, /** Any wood material.*/ kIfcConstructionMaterialResourceTypeEnum_WOOD, /** Undefined resource.*/ kIfcConstructionMaterialResourceTypeEnum_NOTDEFINED, /** User-defined resource.*/ kIfcConstructionMaterialResourceTypeEnum_USERDEFINED, /** The value is unset.*/ kIfcConstructionMaterialResourceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcConstructionMaterialResourceTypeEnum& getUnset() { static OdIfc4x2::IfcConstructionMaterialResourceTypeEnum nullEnum = OdIfc4x2::kIfcConstructionMaterialResourceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration is used to identify the primary purpose of a construction product resource. It describes use of products created for construction, and excludes products of the finished building model. */ enum IfcConstructionProductResourceTypeEnum { /** Construction of assemblies for use as input to the building model or other assemblies.*/ kIfcConstructionProductResourceTypeEnum_ASSEMBLY, /** Construction or placement of forms for placing materials such as concrete.*/ kIfcConstructionProductResourceTypeEnum_FORMWORK, /** User-defined resource.*/ kIfcConstructionProductResourceTypeEnum_USERDEFINED, /** Undefined resource.*/ kIfcConstructionProductResourceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcConstructionProductResourceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcConstructionProductResourceTypeEnum& getUnset() { static OdIfc4x2::IfcConstructionProductResourceTypeEnum nullEnum = OdIfc4x2::kIfcConstructionProductResourceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 programmable such as Discrete Digital Control (DDC).*/ kIfcControllerTypeEnum_PROGRAMMABLE, /** Output is proportional to the control error and optionally time integral and derivative.*/ kIfcControllerTypeEnum_PROPORTIONAL, /** Output is discrete value, can be one of three or more values.*/ kIfcControllerTypeEnum_MULTIPOSITION, /** 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 OdIfc4x2::IfcControllerTypeEnum& getUnset() { static OdIfc4x2::IfcControllerTypeEnum nullEnum = OdIfc4x2::kIfcControllerTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcCooledBeamTypeEnum& getUnset() { static OdIfc4x2::IfcCooledBeamTypeEnum nullEnum = OdIfc4x2::kIfcCooledBeamTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcCoolingTowerTypeEnum& getUnset() { static OdIfc4x2::IfcCoolingTowerTypeEnum nullEnum = OdIfc4x2::kIfcCoolingTowerTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details An IfcCostItemTypeEnum is a list of the available types of cost items. */ enum IfcCostItemTypeEnum { /** User-defined type.*/ kIfcCostItemTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcCostItemTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcCostItemTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcCostItemTypeEnum& getUnset() { static OdIfc4x2::IfcCostItemTypeEnum nullEnum = OdIfc4x2::kIfcCostItemTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcCostScheduleTypeEnum& getUnset() { static OdIfc4x2::IfcCostScheduleTypeEnum nullEnum = OdIfc4x2::kIfcCostScheduleTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 represent a molding being a strip of material to cover the transition of surfaces (often between wall cladding and ceiling).*/ kIfcCoveringTypeEnum_MOLDING, /** The covering is used to represent a skirting board being a strip of material to cover the transition between the wall cladding and the flooring.*/ kIfcCoveringTypeEnum_SKIRTINGBOARD, /** 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, /** A protective capping or covering of a wall or a parapet.*/ kIfcCoveringTypeEnum_COPING, /** 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 OdIfc4x2::IfcCoveringTypeEnum& getUnset() { static OdIfc4x2::IfcCoveringTypeEnum nullEnum = OdIfc4x2::kIfcCoveringTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration is used to identify the primary purpose of a crew resource. */ enum IfcCrewResourceTypeEnum { /** A composition of resources performing administration work in an office.*/ kIfcCrewResourceTypeEnum_OFFICE, /** A composition of resources performing production work on a construction site.*/ kIfcCrewResourceTypeEnum_SITE, /** User-defined resource.*/ kIfcCrewResourceTypeEnum_USERDEFINED, /** Undefined resource.*/ kIfcCrewResourceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcCrewResourceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcCrewResourceTypeEnum& getUnset() { static OdIfc4x2::IfcCrewResourceTypeEnum nullEnum = OdIfc4x2::kIfcCrewResourceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcCurtainWallTypeEnum& getUnset() { static OdIfc4x2::IfcCurtainWallTypeEnum nullEnum = OdIfc4x2::kIfcCurtainWallTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details IfcCurveInterpolationEnum specifies the possible methods for the interpolation of property values given as a curve. */ enum IfcCurveInterpolationEnum { /** Indicates that values between the defined values are to be found by linear interpolation.*/ kIfcCurveInterpolationEnum_LINEAR, /** Indicates that values between the defined values are to be found by linear interpolation of the natural logarithm (base e) of the values.*/ kIfcCurveInterpolationEnum_LOG_LINEAR, /** Indicates that values between the defined values are to be found by linear interpolation of the Briggs' logarithm (base 10) of the values.*/ kIfcCurveInterpolationEnum_LOG_LOG, /** No interpolation information is provided*/ kIfcCurveInterpolationEnum_NOTDEFINED, /** The value is unset.*/ kIfcCurveInterpolationEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcCurveInterpolationEnum& getUnset() { static OdIfc4x2::IfcCurveInterpolationEnum nullEnum = OdIfc4x2::kIfcCurveInterpolationEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration defines the various types of damper */ enum IfcDamperTypeEnum { /** Damper used for purposes of manually balancing pressure differences. Commonly operated by mechanical adjustment.*/ kIfcDamperTypeEnum_BACKDRAFTDAMPER, /** Backdraft damper used to restrict the movement of air in one direction. Commonly operated by mechanical spring.*/ kIfcDamperTypeEnum_BALANCINGDAMPER, /** Blast damper used to prevent protect occupants and equipment against overpressures resultant of an explosion. Commonly operated by mechanical spring.*/ kIfcDamperTypeEnum_BLASTDAMPER, /** 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, /** 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, /** Fume hood exhaust damper. Commonly operated by actuator.*/ kIfcDamperTypeEnum_FUMEHOODEXHAUST, /** 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, /** Relief damper used to allow air to move upon a buildup of a specified pressure differential. Commonly operated by mechanical spring.*/ kIfcDamperTypeEnum_RELIEFDAMPER, /** Smoke damper used to prevent the spread of smoke. Commonly operated by a smoke detector of a building automation system.*/ kIfcDamperTypeEnum_SMOKEDAMPER, /** User-defined damper.*/ kIfcDamperTypeEnum_USERDEFINED, /** Undefined damper.*/ kIfcDamperTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcDamperTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcDamperTypeEnum& getUnset() { static OdIfc4x2::IfcDamperTypeEnum nullEnum = OdIfc4x2::kIfcDamperTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcDataOriginEnum& getUnset() { static OdIfc4x2::IfcDataOriginEnum nullEnum = OdIfc4x2::kIfcDataOriginEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details IfcDerivedUnitEnum is an enumeration type for allowed types of derived units. */ enum IfcDerivedUnitEnum { /** Angularvelocity unit*/ kIfcDerivedUnitEnum_ANGULARVELOCITYUNIT, /** Area density unit*/ kIfcDerivedUnitEnum_AREADENSITYUNIT, /** 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 level unit*/ kIfcDerivedUnitEnum_SOUNDPOWERLEVELUNIT, /** Sound power unit*/ kIfcDerivedUnitEnum_SOUNDPOWERUNIT, /** Sound pressure level unit*/ kIfcDerivedUnitEnum_SOUNDPRESSURELEVELUNIT, /** Sound pressure unit*/ kIfcDerivedUnitEnum_SOUNDPRESSUREUNIT, /** Temperature gradient unit*/ kIfcDerivedUnitEnum_TEMPERATUREGRADIENTUNIT, /** Temperature of change unit*/ kIfcDerivedUnitEnum_TEMPERATURERATEOFCHANGEUNIT, /** 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 OdIfc4x2::IfcDerivedUnitEnum& getUnset() { static OdIfc4x2::IfcDerivedUnitEnum nullEnum = OdIfc4x2::kIfcDerivedUnitEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcDirectionSenseEnum& getUnset() { static OdIfc4x2::IfcDirectionSenseEnum nullEnum = OdIfc4x2::kIfcDirectionSenseEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration defines the different types of discrete accessories. */ enum IfcDiscreteAccessoryTypeEnum { /** An accessory consisting of a steel plate, shear stud connectors or welded-on rebar which is embedded into the surface of a concrete element so that other elements can be welded or bolted onto it later.*/ kIfcDiscreteAccessoryTypeEnum_ANCHORPLATE, /** An L-shaped or similarly shaped accessory attached in a corner between elements to hold them together or to carry a secondary element.*/ kIfcDiscreteAccessoryTypeEnum_BRACKET, /** A column shoe or a beam shoe (beam hanger) used to support or secure an element.*/ kIfcDiscreteAccessoryTypeEnum_SHOE, /** Assembly connection element between construction elements to allow for thermic differential expansions.*/ kIfcDiscreteAccessoryTypeEnum_EXPANSION_JOINT_DEVICE, /** User-defined accessory.*/ kIfcDiscreteAccessoryTypeEnum_USERDEFINED, /** Undefined accessory.*/ kIfcDiscreteAccessoryTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcDiscreteAccessoryTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcDiscreteAccessoryTypeEnum& getUnset() { static OdIfc4x2::IfcDiscreteAccessoryTypeEnum nullEnum = OdIfc4x2::kIfcDiscreteAccessoryTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcDistributionChamberElementTypeEnum& getUnset() { static OdIfc4x2::IfcDistributionChamberElementTypeEnum nullEnum = OdIfc4x2::kIfcDistributionChamberElementTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration identifies different types of distribution ports. It is used to designate ports by their general function, which determines applicable property sets and compatible systems. */ enum IfcDistributionPortTypeEnum { /** Connection to cable segment or fitting for distribution of electricity.*/ kIfcDistributionPortTypeEnum_CABLE, /** Connection to cable carrier segment or fitting for enclosing cables.*/ kIfcDistributionPortTypeEnum_CABLECARRIER, /** Connection to duct segment or fitting for distribution of air.*/ kIfcDistributionPortTypeEnum_DUCT, /** Connection to pipe segment or fitting for distribution of solid, liquid, or gas.*/ kIfcDistributionPortTypeEnum_PIPE, /** User-defined port type.*/ kIfcDistributionPortTypeEnum_USERDEFINED, /** Undefined port type.*/ kIfcDistributionPortTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcDistributionPortTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcDistributionPortTypeEnum& getUnset() { static OdIfc4x2::IfcDistributionPortTypeEnum nullEnum = OdIfc4x2::kIfcDistributionPortTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration identifies different types of distribution systems. It is used to designate systems by their function as well as ports of devices within such systems to restrict connectivity to compatible connections. */ enum IfcDistributionSystemEnum { /** Conditioned air distribution system for purposes of maintaining a temperature range within one or more spaces.*/ kIfcDistributionSystemEnum_AIRCONDITIONING, /** A transport of a single media source, having audio and/or video streams.*/ kIfcDistributionSystemEnum_AUDIOVISUAL, /** Arbitrary chemical further qualified by property set, such as for medical or industrial use.*/ kIfcDistributionSystemEnum_CHEMICAL, /** Nonpotable chilled water, such as circulated through an evaporator.*/ kIfcDistributionSystemEnum_CHILLEDWATER, /** Communication*/ kIfcDistributionSystemEnum_COMMUNICATION, /** Compressed air system.*/ kIfcDistributionSystemEnum_COMPRESSEDAIR, /** Nonpotable water, such as circulated through a condenser.*/ kIfcDistributionSystemEnum_CONDENSERWATER, /** A transport or network dedicated to control system usage.*/ kIfcDistributionSystemEnum_CONTROL, /** Arbitrary supply of substances.*/ kIfcDistributionSystemEnum_CONVEYING, /** A network having general-purpose usage.*/ kIfcDistributionSystemEnum_DATA, /** Arbitrary disposal of substances.*/ kIfcDistributionSystemEnum_DISPOSAL, /** Unheated potable water distribution system.*/ kIfcDistributionSystemEnum_DOMESTICCOLDWATER, /** Heated potable water distribution system.*/ kIfcDistributionSystemEnum_DOMESTICHOTWATER, /** Drainage collection system.*/ kIfcDistributionSystemEnum_DRAINAGE, /** A path for equipotential bonding, conducting current to the ground.*/ kIfcDistributionSystemEnum_EARTHING, /** A circuit for delivering electrical power.*/ kIfcDistributionSystemEnum_ELECTRICAL, /** An amplified audio signal such as for loudspeakers.*/ kIfcDistributionSystemEnum_ELECTROACOUSTIC, /** Exhaust air collection system for removing stale or noxious air from one or more spaces.*/ kIfcDistributionSystemEnum_EXHAUST, /** Fire protection sprinkler system.*/ kIfcDistributionSystemEnum_FIREPROTECTION, /** Arbitrary supply of fuel.*/ kIfcDistributionSystemEnum_FUEL, /** Gas-phase materials such as methane or natural gas.*/ kIfcDistributionSystemEnum_GAS, /** Hazardous material or fluid collection system.*/ kIfcDistributionSystemEnum_HAZARDOUS, /** Water or steam heated from a boiler and circulated through radiators.*/ kIfcDistributionSystemEnum_HEATING, /** A circuit dedicated for lighting, such as a fixture having sockets for lamps.*/ kIfcDistributionSystemEnum_LIGHTING, /** A path for conducting lightning current to the ground.*/ kIfcDistributionSystemEnum_LIGHTNINGPROTECTION, /** Items consumed and discarded, commonly known as trash or garbage.*/ kIfcDistributionSystemEnum_MUNICIPALSOLIDWASTE, /** Oil distribution system.*/ kIfcDistributionSystemEnum_OIL, /** Operating supplies system.*/ kIfcDistributionSystemEnum_OPERATIONAL, /** A path for power generation.*/ kIfcDistributionSystemEnum_POWERGENERATION, /** Rainwater resulting from precipitation which directly falls on a parcel.*/ kIfcDistributionSystemEnum_RAINWATER, /** Refrigerant distribution system for purposes of fulfilling all or parts of a refrigeration cycle.*/ kIfcDistributionSystemEnum_REFRIGERATION, /** A transport or network dedicated to security system usage.*/ kIfcDistributionSystemEnum_SECURITY, /** Sewage collection system.*/ kIfcDistributionSystemEnum_SEWAGE, /** A raw analog signal, such as modulated data or measurements from sensors.*/ kIfcDistributionSystemEnum_SIGNAL, /** Stormwater resulting from precipitation which runs off or travels over the ground surface.*/ kIfcDistributionSystemEnum_STORMWATER, /** A transport or network dedicated to telephone system usage.*/ kIfcDistributionSystemEnum_TELEPHONE, /** A transport of multiple media sources such as analog cable TV, satellite TV, or over-the-air TV.*/ kIfcDistributionSystemEnum_TV, /** Vacuum distribution system.*/ kIfcDistributionSystemEnum_VACUUM, /** Vent system for wastewater piping systems.*/ kIfcDistributionSystemEnum_VENT, /** Ventilation air distribution system involved in either the exchange of air to the outside as well as circulation of air within a building.*/ kIfcDistributionSystemEnum_VENTILATION, /** Water adversely affected in quality by anthropogenic influence, possibly originating from sewage, drainage, or other source.*/ kIfcDistributionSystemEnum_WASTEWATER, /** Arbitrary water supply.*/ kIfcDistributionSystemEnum_WATERSUPPLY, /** No description available.*/ kIfcDistributionSystemEnum_USERDEFINED, /** No description available.*/ kIfcDistributionSystemEnum_NOTDEFINED, /** The value is unset.*/ kIfcDistributionSystemEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcDistributionSystemEnum& getUnset() { static OdIfc4x2::IfcDistributionSystemEnum nullEnum = OdIfc4x2::kIfcDistributionSystemEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcDocumentConfidentialityEnum& getUnset() { static OdIfc4x2::IfcDocumentConfidentialityEnum nullEnum = OdIfc4x2::kIfcDocumentConfidentialityEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcDocumentStatusEnum& getUnset() { static OdIfc4x2::IfcDocumentStatusEnum nullEnum = OdIfc4x2::kIfcDocumentStatusEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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, /** Fixed panel. */ kIfcDoorPanelOperationEnum_FIXEDPANEL, /** User-defined.*/ kIfcDoorPanelOperationEnum_USERDEFINED, /** Not defined.*/ kIfcDoorPanelOperationEnum_NOTDEFINED, /** The value is unset.*/ kIfcDoorPanelOperationEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcDoorPanelOperationEnum& getUnset() { static OdIfc4x2::IfcDoorPanelOperationEnum nullEnum = OdIfc4x2::kIfcDoorPanelOperationEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcDoorPanelPositionEnum& getUnset() { static OdIfc4x2::IfcDoorPanelPositionEnum nullEnum = OdIfc4x2::kIfcDoorPanelPositionEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcDoorStyleConstructionEnum& getUnset() { static OdIfc4x2::IfcDoorStyleConstructionEnum nullEnum = OdIfc4x2::kIfcDoorStyleConstructionEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcDoorStyleOperationEnum& getUnset() { static OdIfc4x2::IfcDoorStyleOperationEnum nullEnum = OdIfc4x2::kIfcDoorStyleOperationEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration defines the different predefined types of an IfcDoor or IfcDoorType object. */ enum IfcDoorTypeEnum { /** A standard door usually within a wall opening, as a door panel in a curtain wall, or as a "free standing" door.*/ kIfcDoorTypeEnum_DOOR, /** A gate is a point of entry into a space usually within an opening in a fence. Or as a "free standing" gate.*/ kIfcDoorTypeEnum_GATE, /** A special door that lies horizonally in a slab opening. Often used for accessing cellar or attic.*/ kIfcDoorTypeEnum_TRAPDOOR, /** User-defined door element.*/ kIfcDoorTypeEnum_USERDEFINED, /** Undefined door element.*/ kIfcDoorTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcDoorTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcDoorTypeEnum& getUnset() { static OdIfc4x2::IfcDoorTypeEnum nullEnum = OdIfc4x2::kIfcDoorTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration defines the basic ways to describe how an IfcDoor or IfcDoorType operate. It combines the partitioning of the access barrier into single or multiple panels and the operation types of those panels. */ enum IfcDoorTypeOperationEnum { /** 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.*/ kIfcDoorTypeOperationEnum_SINGLE_SWING_LEFT, /** Door with one panel that opens (swings) to the right. The hinges are on the right side as viewed in the direction of the positive y-axis.*/ kIfcDoorTypeOperationEnum_SINGLE_SWING_RIGHT, /** Door with two panels, one opens (swings) to the left, the other opens (swings) to the right.*/ kIfcDoorTypeOperationEnum_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.*/ kIfcDoorTypeOperationEnum_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.*/ kIfcDoorTypeOperationEnum_DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT, /** Door with one panel that swings in both directions and to the left in the main traffic direction. Also called double acting door.*/ kIfcDoorTypeOperationEnum_DOUBLE_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.*/ kIfcDoorTypeOperationEnum_DOUBLE_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.*/ kIfcDoorTypeOperationEnum_DOUBLE_DOOR_DOUBLE_SWING, /** Door with one panel that is sliding to the left.*/ kIfcDoorTypeOperationEnum_SLIDING_TO_LEFT, /** Door with one panel that is sliding to the right.*/ kIfcDoorTypeOperationEnum_SLIDING_TO_RIGHT, /** Door with two panels, one is sliding to the left the other is sliding to the right.*/ kIfcDoorTypeOperationEnum_DOUBLE_DOOR_SLIDING, /** Door with one panel that is folding to the left.*/ kIfcDoorTypeOperationEnum_FOLDING_TO_LEFT, /** Door with one panel that is folding to the right.*/ kIfcDoorTypeOperationEnum_FOLDING_TO_RIGHT, /** Door with two panels, one is folding to the left, the other is folding to the right.*/ kIfcDoorTypeOperationEnum_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).*/ kIfcDoorTypeOperationEnum_REVOLVING, /** Door that opens by rolling up.*/ kIfcDoorTypeOperationEnum_ROLLINGUP, /** Door with one panel that opens (swings) to the left and one fixed panel. The hinges of the swinging panel are on the left side as viewed in the direction of the positive y-axis.*/ kIfcDoorTypeOperationEnum_SWING_FIXED_LEFT, /** Door with one panel that opens (swings) to the right and one fixed panel. The hinges of the swinging panel are on the right side as viewed in the direction of the positive y-axis.*/ kIfcDoorTypeOperationEnum_SWING_FIXED_RIGHT, /** User defined operation type.*/ kIfcDoorTypeOperationEnum_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.*/ kIfcDoorTypeOperationEnum_NOTDEFINED, /** The value is unset.*/ kIfcDoorTypeOperationEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcDoorTypeOperationEnum& getUnset() { static OdIfc4x2::IfcDoorTypeOperationEnum nullEnum = OdIfc4x2::kIfcDoorTypeOperationEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcDuctFittingTypeEnum& getUnset() { static OdIfc4x2::IfcDuctFittingTypeEnum nullEnum = OdIfc4x2::kIfcDuctFittingTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcDuctSegmentTypeEnum& getUnset() { static OdIfc4x2::IfcDuctSegmentTypeEnum nullEnum = OdIfc4x2::kIfcDuctSegmentTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcDuctSilencerTypeEnum& getUnset() { static OdIfc4x2::IfcDuctSilencerTypeEnum nullEnum = OdIfc4x2::kIfcDuctSilencerTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details The IfcElectricApplianceTypeEnum defines the range of different types of electrical appliance that can be specified. */ enum IfcElectricApplianceTypeEnum { /** 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, /** An electrical appliance that is used occasionally to provide heat. A freestanding electric heater is a 'plugged' appliance whose load may be removed from an electric circuit.*/ kIfcElectricApplianceTypeEnum_FREESTANDINGELECTRICHEATER, /** 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, /** A small, local electrical appliance for heating water. A freestanding water heater is a 'plugged' appliance whose load may be removed from an electric circuit.*/ kIfcElectricApplianceTypeEnum_FREESTANDINGWATERHEATER, /** A small, local electrical appliance for cooling water. A freestanding water cooler is a 'plugged' appliance whose load may be removed from an electric circuit.*/ kIfcElectricApplianceTypeEnum_FREESTANDINGWATERCOOLER, /** 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, /** A specialized appliance used in commercial kitchens such as a mixer.*/ kIfcElectricApplianceTypeEnum_KITCHENMACHINE, /** 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, /** An electrical appliance that has the primary function of storing food at low temperature but above the freezing point of water.*/ kIfcElectricApplianceTypeEnum_REFRIGERATOR, /** An electrical appliance that has the primary function of drying clothes.*/ kIfcElectricApplianceTypeEnum_TUMBLEDRYER, /** 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, /** User-defined type.*/ kIfcElectricApplianceTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcElectricApplianceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcElectricApplianceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcElectricApplianceTypeEnum& getUnset() { static OdIfc4x2::IfcElectricApplianceTypeEnum nullEnum = OdIfc4x2::kIfcElectricApplianceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details The IfcElectricDistributionBoardTypeEnum defines different types and/or functions of electric distribution boards. */ enum IfcElectricDistributionBoardTypeEnum { /** A distribution point on the incoming electrical supply, typically in domestic premises, at which protective devices are located.*/ kIfcElectricDistributionBoardTypeEnum_CONSUMERUNIT, /** A distribution point at which connections are made for distribution of electrical circuits usually through protective devices.*/ kIfcElectricDistributionBoardTypeEnum_DISTRIBUTIONBOARD, /** A distribution point at which starting and control devices for major plant items are located.*/ kIfcElectricDistributionBoardTypeEnum_MOTORCONTROLCENTRE, /** A distribution point at which switching devices are located.*/ kIfcElectricDistributionBoardTypeEnum_SWITCHBOARD, /** User-defined type.*/ kIfcElectricDistributionBoardTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcElectricDistributionBoardTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcElectricDistributionBoardTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcElectricDistributionBoardTypeEnum& getUnset() { static OdIfc4x2::IfcElectricDistributionBoardTypeEnum nullEnum = OdIfc4x2::kIfcElectricDistributionBoardTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcElectricFlowStorageDeviceTypeEnum& getUnset() { static OdIfc4x2::IfcElectricFlowStorageDeviceTypeEnum nullEnum = OdIfc4x2::kIfcElectricFlowStorageDeviceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details The IfcElectricGeneratorTypeEnum defines different types of electric generators. */ enum IfcElectricGeneratorTypeEnum { /** Combined heat and power supply, used not only as a source of electric energy but also as a heating source for the building. It may therefore be not only part of an electrical system but also of a heating system.*/ kIfcElectricGeneratorTypeEnum_CHP, /** Electrical generator with a fuel-driven engine, for example a diesel-driven emergency power supply.*/ kIfcElectricGeneratorTypeEnum_ENGINEGENERATOR, /** Electrical generator which does not include its source of kinetic energy, that is, a motor, engine, or turbine are all modeled separately.*/ kIfcElectricGeneratorTypeEnum_STANDALONE, /** User-defined type.*/ kIfcElectricGeneratorTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcElectricGeneratorTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcElectricGeneratorTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcElectricGeneratorTypeEnum& getUnset() { static OdIfc4x2::IfcElectricGeneratorTypeEnum nullEnum = OdIfc4x2::kIfcElectricGeneratorTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcElectricMotorTypeEnum& getUnset() { static OdIfc4x2::IfcElectricMotorTypeEnum nullEnum = OdIfc4x2::kIfcElectricMotorTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcElectricTimeControlTypeEnum& getUnset() { static OdIfc4x2::IfcElectricTimeControlTypeEnum nullEnum = OdIfc4x2::kIfcElectricTimeControlTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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, /** A bridge abutment built up of walls, beams, slabs etc.*/ kIfcElementAssemblyTypeEnum_ABUTMENT, /** An intermediate support e.g. in a bridge, built up of walls, columns, beams etc.*/ kIfcElementAssemblyTypeEnum_PIER, /** A vertical structure supporting cables in suspended or stayed structure.*/ kIfcElementAssemblyTypeEnum_PYLON, /** A Structural linear member or assembly of members inside a box girder or between girders, typically on a pier, to resist lateral forces and transfer them to the support.*/ kIfcElementAssemblyTypeEnum_CROSS_BRACING, /** A platform (such as floor or bridge deck) built up of beams, slabs.*/ kIfcElementAssemblyTypeEnum_DECK, /** User-defined element assembly.*/ kIfcElementAssemblyTypeEnum_USERDEFINED, /** Undefined element assembly.*/ kIfcElementAssemblyTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcElementAssemblyTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcElementAssemblyTypeEnum& getUnset() { static OdIfc4x2::IfcElementAssemblyTypeEnum nullEnum = OdIfc4x2::kIfcElementAssemblyTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcElementCompositionEnum& getUnset() { static OdIfc4x2::IfcElementCompositionEnum nullEnum = OdIfc4x2::kIfcElementCompositionEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details Enumeration defining the typical types of engines. */ enum IfcEngineTypeEnum { /** Combustion is external.*/ kIfcEngineTypeEnum_EXTERNALCOMBUSTION, /** Combustion is internal.*/ kIfcEngineTypeEnum_INTERNALCOMBUSTION, /** User-defined engine type.*/ kIfcEngineTypeEnum_USERDEFINED, /** Undefined engine type.*/ kIfcEngineTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcEngineTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcEngineTypeEnum& getUnset() { static OdIfc4x2::IfcEngineTypeEnum nullEnum = OdIfc4x2::kIfcEngineTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcEvaporativeCoolerTypeEnum& getUnset() { static OdIfc4x2::IfcEvaporativeCoolerTypeEnum nullEnum = OdIfc4x2::kIfcEvaporativeCoolerTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details Enumeration defining the typical types of evaporators. */ enum IfcEvaporatorTypeEnum { /** Direct-expansion evaporator.*/ kIfcEvaporatorTypeEnum_DIRECTEXPANSION, /** 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 OdIfc4x2::IfcEvaporatorTypeEnum& getUnset() { static OdIfc4x2::IfcEvaporatorTypeEnum nullEnum = OdIfc4x2::kIfcEvaporatorTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details The IfcEventTriggerTypeEnum defines the range of different types of event trigger that can be specified. The definition of event trigger types has been adopted from the Business Process Modeling Notation (BPMN), which is also used in the Information Delivery Manual (IDM) for defining business processes. More detailed information about the use of event trigger types can be found in these specifications. */ enum IfcEventTriggerTypeEnum { /** An event trigger that is a rule or constraint.*/ kIfcEventTriggerTypeEnum_EVENTRULE, /** An event trigger that is a message or set of information.*/ kIfcEventTriggerTypeEnum_EVENTMESSAGE, /** An event trigger that is at, or occurs after, a particular point in or period of time.*/ kIfcEventTriggerTypeEnum_EVENTTIME, /** An event trigger that is a complex combination of things.*/ kIfcEventTriggerTypeEnum_EVENTCOMPLEX, /** User defined.*/ kIfcEventTriggerTypeEnum_USERDEFINED, /** Not defined.*/ kIfcEventTriggerTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcEventTriggerTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcEventTriggerTypeEnum& getUnset() { static OdIfc4x2::IfcEventTriggerTypeEnum nullEnum = OdIfc4x2::kIfcEventTriggerTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details The IfcEventTypeEnum defines the range of different types of event that can be specified. */ enum IfcEventTypeEnum { /** An initiating event of a process.*/ kIfcEventTypeEnum_STARTEVENT, /** A terminating event of a process.*/ kIfcEventTypeEnum_ENDEVENT, /** An event that occurs at an intermediate stage of a process.*/ kIfcEventTypeEnum_INTERMEDIATEEVENT, /** User defined.*/ kIfcEventTypeEnum_USERDEFINED, /** Not defined.*/ kIfcEventTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcEventTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcEventTypeEnum& getUnset() { static OdIfc4x2::IfcEventTypeEnum nullEnum = OdIfc4x2::kIfcEventTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration defines the different types of external spatial elements. */ enum IfcExternalSpatialElementTypeEnum { /** External air space around the building.*/ kIfcExternalSpatialElementTypeEnum_EXTERNAL, /** External volume covered by earth around the building.*/ kIfcExternalSpatialElementTypeEnum_EXTERNAL_EARTH, /** External volume covered with water around the building.*/ kIfcExternalSpatialElementTypeEnum_EXTERNAL_WATER, /** Space occupied by a neighboring building.*/ kIfcExternalSpatialElementTypeEnum_EXTERNAL_FIRE, /** No description available.*/ kIfcExternalSpatialElementTypeEnum_USERDEFINED, /** No description available.*/ kIfcExternalSpatialElementTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcExternalSpatialElementTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcExternalSpatialElementTypeEnum& getUnset() { static OdIfc4x2::IfcExternalSpatialElementTypeEnum nullEnum = OdIfc4x2::kIfcExternalSpatialElementTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcFanTypeEnum& getUnset() { static OdIfc4x2::IfcFanTypeEnum nullEnum = OdIfc4x2::kIfcFanTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration defines the different types of fasteners, except for mechanical fasteners. */ enum IfcFastenerTypeEnum { /** A fastening connection where glue is used to join together elements.*/ kIfcFastenerTypeEnum_GLUE, /** A composition of mineralic or other materials used to fill jointing gaps and possibly fulfilling a load carrying role.*/ kIfcFastenerTypeEnum_MORTAR, /** A weld seam between parts of metallic material or other suitable materials.*/ kIfcFastenerTypeEnum_WELD, /** User-defined fastener.*/ kIfcFastenerTypeEnum_USERDEFINED, /** Undefined fastener.*/ kIfcFastenerTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcFastenerTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcFastenerTypeEnum& getUnset() { static OdIfc4x2::IfcFastenerTypeEnum nullEnum = OdIfc4x2::kIfcFastenerTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 particulates from compressed air.*/ kIfcFilterTypeEnum_COMPRESSEDAIRFILTER, /** 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 OdIfc4x2::IfcFilterTypeEnum& getUnset() { static OdIfc4x2::IfcFilterTypeEnum nullEnum = OdIfc4x2::kIfcFilterTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcFireSuppressionTerminalTypeEnum& getUnset() { static OdIfc4x2::IfcFireSuppressionTerminalTypeEnum nullEnum = OdIfc4x2::kIfcFireSuppressionTerminalTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcFlowDirectionEnum& getUnset() { static OdIfc4x2::IfcFlowDirectionEnum nullEnum = OdIfc4x2::kIfcFlowDirectionEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcFlowInstrumentTypeEnum& getUnset() { static OdIfc4x2::IfcFlowInstrumentTypeEnum nullEnum = OdIfc4x2::kIfcFlowInstrumentTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration defines various types of flow meter: */ enum IfcFlowMeterTypeEnum { /** 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, /** 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 OdIfc4x2::IfcFlowMeterTypeEnum& getUnset() { static OdIfc4x2::IfcFlowMeterTypeEnum nullEnum = OdIfc4x2::kIfcFlowMeterTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details Enumeration defining the generic footing type. */ enum IfcFootingTypeEnum { /** A foundation construction type used in underwater construction.*/ kIfcFootingTypeEnum_CAISSON_FOUNDATION, /** 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 OdIfc4x2::IfcFootingTypeEnum& getUnset() { static OdIfc4x2::IfcFootingTypeEnum nullEnum = OdIfc4x2::kIfcFootingTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details IfcFurnitureTypeEnum defines the types of furniture from which the type required can be selected. */ enum IfcFurnitureTypeEnum { /** Furniture for seating a single person.*/ kIfcFurnitureTypeEnum_CHAIR, /** Furniture with a countertop for multiple people.*/ kIfcFurnitureTypeEnum_TABLE, /** Furniture with a countertop and optional drawers for a single person.*/ kIfcFurnitureTypeEnum_DESK, /** Furniture for sleeping.*/ kIfcFurnitureTypeEnum_BED, /** Furniture with sliding drawers for storing files.*/ kIfcFurnitureTypeEnum_FILECABINET, /** Furniture for storing books or other items.*/ kIfcFurnitureTypeEnum_SHELF, /** Furniture for seating multiple people.*/ kIfcFurnitureTypeEnum_SOFA, /** User-defined type.*/ kIfcFurnitureTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcFurnitureTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcFurnitureTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcFurnitureTypeEnum& getUnset() { static OdIfc4x2::IfcFurnitureTypeEnum nullEnum = OdIfc4x2::kIfcFurnitureTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration defines the different predefined types of geographic elements that can further specify an IfcGeographicElement or an IfcGeographicElementType. */ enum IfcGeographicElementTypeEnum { /** Terrain*/ kIfcGeographicElementTypeEnum_TERRAIN, /** Soil boring point*/ kIfcGeographicElementTypeEnum_SOIL_BORING_POINT, /** User defined*/ kIfcGeographicElementTypeEnum_USERDEFINED, /** Not defined*/ kIfcGeographicElementTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcGeographicElementTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcGeographicElementTypeEnum& getUnset() { static OdIfc4x2::IfcGeographicElementTypeEnum nullEnum = OdIfc4x2::kIfcGeographicElementTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcGeometricProjectionEnum& getUnset() { static OdIfc4x2::IfcGeometricProjectionEnum nullEnum = OdIfc4x2::kIfcGeometricProjectionEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcGlobalOrLocalEnum& getUnset() { static OdIfc4x2::IfcGlobalOrLocalEnum nullEnum = OdIfc4x2::kIfcGlobalOrLocalEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration defines the different layout types of grids. Restriction on the correct use of IfcGrid instantiations may be imposed depending on the value of the being IfcGridTypeEnum. */ enum IfcGridTypeEnum { /** An IfcGrid with straight u-axes and straight v-axes being perpendicular to each other. All grid axes being part of u-axes can be described by one axis line and all other axes being 2D offsets from this axis line. The same applies to all grid axes being part of V-axes.*/ kIfcGridTypeEnum_RECTANGULAR, /** An IfcGrid with straight u-axes and curved v-axes. All grid axes being part of V-axes have the same center point and are concentric circular arcs. All grid axes being part of u-axes intersect at the same center point and rotate counter clockwise.*/ kIfcGridTypeEnum_RADIAL, /** An IfcGrid with u-axes, v-axes, and w-axes all being co-linear axis lines with a 2D offset. The v-axes are at 60 degree rotated counter clockwise from the u-axes, and the w-axes are at 120 degree rotated counter clockwise from the u-axes.*/ kIfcGridTypeEnum_TRIANGULAR, /** An IfcGrid with u-axes, v-axes, and optionally w-axes that cannot be described by the patterns.*/ kIfcGridTypeEnum_IRREGULAR, /** Any other grid not conforming to any of the above restrictions.*/ kIfcGridTypeEnum_USERDEFINED, /** Not known whether grid conforms to any standard type.*/ kIfcGridTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcGridTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcGridTypeEnum& getUnset() { static OdIfc4x2::IfcGridTypeEnum nullEnum = OdIfc4x2::kIfcGridTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcHeatExchangerTypeEnum& getUnset() { static OdIfc4x2::IfcHeatExchangerTypeEnum nullEnum = OdIfc4x2::kIfcHeatExchangerTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcHumidifierTypeEnum& getUnset() { static OdIfc4x2::IfcHumidifierTypeEnum nullEnum = OdIfc4x2::kIfcHumidifierTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details The IfcInterceptorTypeEnum defines the range of different types of interceptor that can be specified. */ enum IfcInterceptorTypeEnum { /** Removes larger liquid drops or larger solid particles.*/ kIfcInterceptorTypeEnum_CYCLONIC, /** Chamber, on the line of a drain or discharge pipe, that prevents grease passing into a drainage system.*/ kIfcInterceptorTypeEnum_GREASE, /** One or more chambers arranged to prevent the ingress of oil to a drain or sewer that retains the oil for later removal.*/ kIfcInterceptorTypeEnum_OIL, /** Two or more chambers with inlet and outlet pipes arranged to allow petrol/gasoline collected on the surface of water drained into them to evaporate through ventilating pipes.*/ kIfcInterceptorTypeEnum_PETROL, /** User-defined type.*/ kIfcInterceptorTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcInterceptorTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcInterceptorTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcInterceptorTypeEnum& getUnset() { static OdIfc4x2::IfcInterceptorTypeEnum nullEnum = OdIfc4x2::kIfcInterceptorTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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, /** The space boundary faces a physical or virtual element where there is earth (or terrain) on the other side.*/ kIfcInternalOrExternalEnum_EXTERNAL_EARTH, /** The space boundary faces a physical or virtual element where there is water (water component of terrain) on the other side.*/ kIfcInternalOrExternalEnum_EXTERNAL_WATER, /** The space boundary faces a physical or virtual element where there is another building on the other side.*/ kIfcInternalOrExternalEnum_EXTERNAL_FIRE, /** No information available.*/ kIfcInternalOrExternalEnum_NOTDEFINED, /** The value is unset.*/ kIfcInternalOrExternalEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcInternalOrExternalEnum& getUnset() { static OdIfc4x2::IfcInternalOrExternalEnum nullEnum = OdIfc4x2::kIfcInternalOrExternalEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcInventoryTypeEnum& getUnset() { static OdIfc4x2::IfcInventoryTypeEnum nullEnum = OdIfc4x2::kIfcInventoryTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details The IfcJunctionBoxTypeEnum defines different types of junction boxes. */ enum IfcJunctionBoxTypeEnum { /** Contains cables, outlets, and/or switches for communications use.*/ kIfcJunctionBoxTypeEnum_DATA, /** Contains cables, outlets, and/or switches for electrical power.*/ kIfcJunctionBoxTypeEnum_POWER, /** User-defined type.*/ kIfcJunctionBoxTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcJunctionBoxTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcJunctionBoxTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcJunctionBoxTypeEnum& getUnset() { static OdIfc4x2::IfcJunctionBoxTypeEnum nullEnum = OdIfc4x2::kIfcJunctionBoxTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details The IfcKnotType indicates the particular form of b-spline knots. */ enum IfcKnotType { /** The form of knots appropriate for a uniform B-spline curve.*/ kIfcKnotType_UNIFORM_KNOTS, /** The form of knots appropriate for a quasi-uniform B-spline curve.*/ kIfcKnotType_QUASI_UNIFORM_KNOTS, /** The form of knots appropriate for a piecewise Bezier curve.*/ kIfcKnotType_PIECEWISE_BEZIER_KNOTS, /** The type of knots is not specified. This includes the case of non uniform knots.*/ kIfcKnotType_UNSPECIFIED, /** The value is unset.*/ kIfcKnotType_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcKnotType& getUnset() { static OdIfc4x2::IfcKnotType nullEnum = OdIfc4x2::kIfcKnotType_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration is used to identify the primary purpose of a labour resource, and is limited to high-level categories based upon common skill sets. */ enum IfcLaborResourceTypeEnum { /** Coordination of work.*/ kIfcLaborResourceTypeEnum_ADMINISTRATION, /** Rough carpentry including framing.*/ kIfcLaborResourceTypeEnum_CARPENTRY, /** Removal of dust and debris.*/ kIfcLaborResourceTypeEnum_CLEANING, /** Concrete.*/ kIfcLaborResourceTypeEnum_CONCRETE, /** Gypsum wallboard placement and taping.*/ kIfcLaborResourceTypeEnum_DRYWALL, /** Electrical fixtures, equipment, and cables.*/ kIfcLaborResourceTypeEnum_ELECTRIC, /** Finish carpentry including custom cabinetry.*/ kIfcLaborResourceTypeEnum_FINISHING, /** Flooring.*/ kIfcLaborResourceTypeEnum_FLOORING, /** General labour not requiring specific skill.*/ kIfcLaborResourceTypeEnum_GENERAL, /** Heating and ventilation fixtures, equipment, and ducts.*/ kIfcLaborResourceTypeEnum_HVAC, /** Grass, plants, trees, or irrigation.*/ kIfcLaborResourceTypeEnum_LANDSCAPING, /** Laying bricks or blocks with mortar.*/ kIfcLaborResourceTypeEnum_MASONRY, /** Applying decorative coatings or coverings.*/ kIfcLaborResourceTypeEnum_PAINTING, /** Asphalt or concrete roads and walkways.*/ kIfcLaborResourceTypeEnum_PAVING, /** Plumbing fixtures, equipment, and pipes.*/ kIfcLaborResourceTypeEnum_PLUMBING, /** Membranes, shingles, tile, or other roofing.*/ kIfcLaborResourceTypeEnum_ROOFING, /** Excavating, filling, or contouring earth.*/ kIfcLaborResourceTypeEnum_SITEGRADING, /** Erecting and attaching steel elements.*/ kIfcLaborResourceTypeEnum_STEELWORK, /** Determining positions, distances, and angles.*/ kIfcLaborResourceTypeEnum_SURVEYING, /** User-defined resource.*/ kIfcLaborResourceTypeEnum_USERDEFINED, /** Undefined resource.*/ kIfcLaborResourceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcLaborResourceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcLaborResourceTypeEnum& getUnset() { static OdIfc4x2::IfcLaborResourceTypeEnum nullEnum = OdIfc4x2::kIfcLaborResourceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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, /** An incandescent lamp in which a tungsten filament is sealed into a compact transport envelope filled with an inert gas and a small amount of halogen such as iodine or bromine.*/ kIfcLampTypeEnum_HALOGEN, /** 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 solid state lamp that uses light-emitting diodes as the source of light.*/ kIfcLampTypeEnum_LED, /** A discharge lamp in which most of the light is emitted by exciting a metal halide.*/ kIfcLampTypeEnum_METALHALIDE, /** A solid state lamp that uses light-emitting diodes as the source of light whose emissive electroluminescent layer is composed of a film of organic compounds.*/ kIfcLampTypeEnum_OLED, /** 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 OdIfc4x2::IfcLampTypeEnum& getUnset() { static OdIfc4x2::IfcLampTypeEnum nullEnum = OdIfc4x2::kIfcLampTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcLayerSetDirectionEnum& getUnset() { static OdIfc4x2::IfcLayerSetDirectionEnum nullEnum = OdIfc4x2::kIfcLayerSetDirectionEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcLightDistributionCurveEnum& getUnset() { static OdIfc4x2::IfcLightDistributionCurveEnum nullEnum = OdIfc4x2::kIfcLightDistributionCurveEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcLightEmissionSourceEnum& getUnset() { static OdIfc4x2::IfcLightEmissionSourceEnum nullEnum = OdIfc4x2::kIfcLightEmissionSourceEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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, /** A light fixture having specific purpose of directing occupants in an emergency, such as an illuminated exit sign or emergency flood light.*/ kIfcLightFixtureTypeEnum_SECURITYLIGHTING, /** User-defined type.*/ kIfcLightFixtureTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcLightFixtureTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcLightFixtureTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcLightFixtureTypeEnum& getUnset() { static OdIfc4x2::IfcLightFixtureTypeEnum nullEnum = OdIfc4x2::kIfcLightFixtureTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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, /** 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 OdIfc4x2::IfcLoadGroupTypeEnum& getUnset() { static OdIfc4x2::IfcLoadGroupTypeEnum nullEnum = OdIfc4x2::kIfcLoadGroupTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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, /** Defines a relationship between operands whereby the result is true if exactly one operand is true (exclusive or).*/ kIfcLogicalOperatorEnum_LOGICALXOR, /** Defines a relationship between operands whereby the result is true if at least one operand is false, and false if all operands are true.*/ kIfcLogicalOperatorEnum_LOGICALNOTAND, /** Defines a relationship between operands whereby the result is true if all operands are false, and false if at least one operand is true.*/ kIfcLogicalOperatorEnum_LOGICALNOTOR, /** The value is unset.*/ kIfcLogicalOperatorEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcLogicalOperatorEnum& getUnset() { static OdIfc4x2::IfcLogicalOperatorEnum nullEnum = OdIfc4x2::kIfcLogicalOperatorEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration defines the different types of mechanical fasteners. */ enum IfcMechanicalFastenerTypeEnum { /** A special bolt which is anchored into concrete, stone, or brickwork.*/ kIfcMechanicalFastenerTypeEnum_ANCHORBOLT, /** A threaded cylindrical rod that engages with a similarly threaded hole in a nut or any other part to form a fastener. The mechanical fastener often also includes one or more washers and one or more nuts.*/ kIfcMechanicalFastenerTypeEnum_BOLT, /** A cylindrical rod that is driven into holes of the connected pieces.*/ kIfcMechanicalFastenerTypeEnum_DOWEL, /** A thin pointed piece of metal that is hammered into materials as a fastener.*/ kIfcMechanicalFastenerTypeEnum_NAIL, /** A piece of sheet metal with punched points that overlaps the connected pieces and is pressed into their material.*/ kIfcMechanicalFastenerTypeEnum_NAILPLATE, /** A fastening part having a head at one end and the other end being hammered flat after being passed through holes in the pieces that are fastened together.*/ kIfcMechanicalFastenerTypeEnum_RIVET, /** A fastener with a tapered threaded shank and a slotted head.*/ kIfcMechanicalFastenerTypeEnum_SCREW, /** A ring connector that is accepted by ring keyways in the connected pieces; or a toothed circular or square connector that is pressed into the connected pieces.*/ kIfcMechanicalFastenerTypeEnum_SHEARCONNECTOR, /** A doubly pointed piece of metal that is hammered into materials as a fastener.*/ kIfcMechanicalFastenerTypeEnum_STAPLE, /** Stud shear connectors are cylindrical fastening parts with a head on one side. On the other side they are welded on steel members for the use in composite steel and concrete structures.*/ kIfcMechanicalFastenerTypeEnum_STUDSHEARCONNECTOR, /** A part connecting two rod or bars, such as reinforcement bars.*/ kIfcMechanicalFastenerTypeEnum_COUPLER, /** User-defined mechanical fastener.*/ kIfcMechanicalFastenerTypeEnum_USERDEFINED, /** Undefined mechanical fastener.*/ kIfcMechanicalFastenerTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcMechanicalFastenerTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcMechanicalFastenerTypeEnum& getUnset() { static OdIfc4x2::IfcMechanicalFastenerTypeEnum nullEnum = OdIfc4x2::kIfcMechanicalFastenerTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details Enumeration defining the functional type of medical device. */ enum IfcMedicalDeviceTypeEnum { /** Device that provides purified medical air, composed of an air compressor and air treatment line.*/ kIfcMedicalDeviceTypeEnum_AIRSTATION, /** Device that feeds air to an oxygen generator, composed of an air compressor, air treatment line, and an air receiver.*/ kIfcMedicalDeviceTypeEnum_FEEDAIRUNIT, /** Device that generates oxygen from air.*/ kIfcMedicalDeviceTypeEnum_OXYGENGENERATOR, /** Device that combines a feed air unit, oxygen generator, and backup oxygen cylinders.*/ kIfcMedicalDeviceTypeEnum_OXYGENPLANT, /** Device that provides suction, composed of a vacuum pump and bacterial filtration line.*/ kIfcMedicalDeviceTypeEnum_VACUUMSTATION, /** User-defined medical device type.*/ kIfcMedicalDeviceTypeEnum_USERDEFINED, /** Undefined medical device type.*/ kIfcMedicalDeviceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcMedicalDeviceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcMedicalDeviceTypeEnum& getUnset() { static OdIfc4x2::IfcMedicalDeviceTypeEnum nullEnum = OdIfc4x2::kIfcMedicalDeviceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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, /** A linear element added to a flange or a web plate of a girder for local stiffening.*/ kIfcMemberTypeEnum_STIFFENING_RIB, /** Individual segment of an arch structure.*/ kIfcMemberTypeEnum_ARCH_SEGMENT, /** A suspended element, typically comprising steel wire, sheath, etc.*/ kIfcMemberTypeEnum_SUSPENSION_CABLE, /** A vertical element suspending a structure (such as bridge deck) from a suspension cable or an arch.*/ kIfcMemberTypeEnum_SUSPENDER, /** A sloped element suspending a structure (such as bridge deck) from a pylon.*/ kIfcMemberTypeEnum_STAY_CABLE, /** User-defined linear element.*/ kIfcMemberTypeEnum_USERDEFINED, /** Undefined linear element.*/ kIfcMemberTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcMemberTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcMemberTypeEnum& getUnset() { static OdIfc4x2::IfcMemberTypeEnum nullEnum = OdIfc4x2::kIfcMemberTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcMotorConnectionTypeEnum& getUnset() { static OdIfc4x2::IfcMotorConnectionTypeEnum nullEnum = OdIfc4x2::kIfcMotorConnectionTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcNullStyle& getUnset() { static OdIfc4x2::IfcNullStyle nullEnum = OdIfc4x2::kIfcNullStyle_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcObjectTypeEnum& getUnset() { static OdIfc4x2::IfcObjectTypeEnum nullEnum = OdIfc4x2::kIfcObjectTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 identify an agreement that code compliance requirements (the waiver) will not be enforced.*/ kIfcObjectiveEnum_CODEWAIVER, /** A constraint whose objective is to ensure satisfaction of a design intent provision.*/ kIfcObjectiveEnum_DESIGNINTENT, /** A constraint whose objective is to synchronize data with an external source such as a file*/ kIfcObjectiveEnum_EXTERNAL, /** A constraint whose objective is to ensure satisfaction of a health and safety provision.*/ kIfcObjectiveEnum_HEALTHANDSAFETY, /** A constraint whose objective is to resolve a conflict such as merging data from multiple sources.*/ kIfcObjectiveEnum_MERGECONFLICT, /** A constraint whose objective is to ensure data conforms to a model view definition.*/ kIfcObjectiveEnum_MODELVIEW, /** A constraint whose objective is to calculate a value based on other referenced values.*/ kIfcObjectiveEnum_PARAMETER, /** 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 OdIfc4x2::IfcObjectiveEnum& getUnset() { static OdIfc4x2::IfcObjectiveEnum nullEnum = OdIfc4x2::kIfcObjectiveEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcOccupantTypeEnum& getUnset() { static OdIfc4x2::IfcOccupantTypeEnum nullEnum = OdIfc4x2::kIfcOccupantTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration defines the basic types for opening elements. */ enum IfcOpeningElementTypeEnum { /** An opening as subtraction feature that cuts through the element it voids. It thereby creates a hole. An opening in addition has a particular meaning for either providing a void for doors or windows, or an opening to permit flow of air and passing of light.*/ kIfcOpeningElementTypeEnum_OPENING, /** An opening as subtraction feature that does not cut through the element it voids. It creates a niche or similar voiding pattern.*/ kIfcOpeningElementTypeEnum_RECESS, /** User-defined opening element.*/ kIfcOpeningElementTypeEnum_USERDEFINED, /** Undefined opening element.*/ kIfcOpeningElementTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcOpeningElementTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcOpeningElementTypeEnum& getUnset() { static OdIfc4x2::IfcOpeningElementTypeEnum nullEnum = OdIfc4x2::kIfcOpeningElementTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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, /** An outlet used for connecting data communications equipment.*/ kIfcOutletTypeEnum_DATAOUTLET, /** An outlet used for connecting telephone communications equipment.*/ kIfcOutletTypeEnum_TELEPHONEOUTLET, /** User-defined type.*/ kIfcOutletTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcOutletTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcOutletTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcOutletTypeEnum& getUnset() { static OdIfc4x2::IfcOutletTypeEnum nullEnum = OdIfc4x2::kIfcOutletTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration is used to identify the primary purpose of performance history. The IfcPerformanceHistoryTypeEnum contains the following: */ enum IfcPerformanceHistoryTypeEnum { /** User defined.*/ kIfcPerformanceHistoryTypeEnum_USERDEFINED, /** Undefined.*/ kIfcPerformanceHistoryTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcPerformanceHistoryTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcPerformanceHistoryTypeEnum& getUnset() { static OdIfc4x2::IfcPerformanceHistoryTypeEnum nullEnum = OdIfc4x2::kIfcPerformanceHistoryTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcPermeableCoveringOperationEnum& getUnset() { static OdIfc4x2::IfcPermeableCoveringOperationEnum nullEnum = OdIfc4x2::kIfcPermeableCoveringOperationEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details IfcPermitTypeEnum defines the types of permits that can be granted. */ enum IfcPermitTypeEnum { /** Enables access to an identified area.*/ kIfcPermitTypeEnum_ACCESS, /** Enables work to proceed by getting regulatory permissions.*/ kIfcPermitTypeEnum_BUILDING, /** Enables work to be carried out in an identified area.*/ kIfcPermitTypeEnum_WORK, /** User-defined type.*/ kIfcPermitTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcPermitTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcPermitTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcPermitTypeEnum& getUnset() { static OdIfc4x2::IfcPermitTypeEnum nullEnum = OdIfc4x2::kIfcPermitTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcPhysicalOrVirtualEnum& getUnset() { static OdIfc4x2::IfcPhysicalOrVirtualEnum nullEnum = OdIfc4x2::kIfcPhysicalOrVirtualEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcPileConstructionEnum& getUnset() { static OdIfc4x2::IfcPileConstructionEnum nullEnum = OdIfc4x2::kIfcPileConstructionEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details Enumeration defining the pile type. */ enum IfcPileTypeEnum { /** A bore pile.*/ kIfcPileTypeEnum_BORED, /** A rammed, vibrated, or otherwise driven pile.*/ kIfcPileTypeEnum_DRIVEN, /** An injected pile-like construction.*/ kIfcPileTypeEnum_JETGROUTING, /** 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 OdIfc4x2::IfcPileTypeEnum& getUnset() { static OdIfc4x2::IfcPileTypeEnum nullEnum = OdIfc4x2::kIfcPileTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcPipeFittingTypeEnum& getUnset() { static OdIfc4x2::IfcPipeFittingTypeEnum nullEnum = OdIfc4x2::kIfcPipeFittingTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 covered channel or large pipe that forms a watercourse below ground level, usually under a road or railway.*/ kIfcPipeSegmentTypeEnum_CULVERT, /** 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 OdIfc4x2::IfcPipeSegmentTypeEnum& getUnset() { static OdIfc4x2::IfcPipeSegmentTypeEnum nullEnum = OdIfc4x2::kIfcPipeSegmentTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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, /** A flange plate in linear members having box or I-profile (e.g. top or bottom flange plate in box-girder).*/ kIfcPlateTypeEnum_FLANGE_PLATE, /** A plate connecting flange plates in linear members having box or I-profile.*/ kIfcPlateTypeEnum_WEB_PLATE, /** A transversal plate added to a flange or a web plate for local stiffening.*/ kIfcPlateTypeEnum_STIFFENER_PLATE, /** a plate or bracket for strengthening an angle in framework (as in a building or bridge).*/ kIfcPlateTypeEnum_GUSSET_PLATE, /** A plate (underneath or above) a flange to provide additional load capacity.*/ kIfcPlateTypeEnum_COVER_PLATE, /** A plate connecting two members joined at ends.*/ kIfcPlateTypeEnum_SPLICE_PLATE, /** A plate used to spread load over a surface, such as underneath a bearing or column.*/ kIfcPlateTypeEnum_BASE_PLATE, /** User-defined linear element.*/ kIfcPlateTypeEnum_USERDEFINED, /** Undefined linear element.*/ kIfcPlateTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcPlateTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcPlateTypeEnum& getUnset() { static OdIfc4x2::IfcPlateTypeEnum nullEnum = OdIfc4x2::kIfcPlateTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details The IfcPreferredSurfaceCurveRepresentation indicates the preferred form of an edge curve representation. */ enum IfcPreferredSurfaceCurveRepresentation { /** The curve in three-dimensional space is preferred*/ kIfcPreferredSurfaceCurveRepresentation_CURVE3D, /** The first pcurve is preferred*/ kIfcPreferredSurfaceCurveRepresentation_PCURVE_S1, /** The second pcurve is preferred*/ kIfcPreferredSurfaceCurveRepresentation_PCURVE_S2, /** The value is unset.*/ kIfcPreferredSurfaceCurveRepresentation_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcPreferredSurfaceCurveRepresentation& getUnset() { static OdIfc4x2::IfcPreferredSurfaceCurveRepresentation nullEnum = OdIfc4x2::kIfcPreferredSurfaceCurveRepresentation_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcProcedureTypeEnum& getUnset() { static OdIfc4x2::IfcProcedureTypeEnum nullEnum = OdIfc4x2::kIfcProcedureTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcProfileTypeEnum& getUnset() { static OdIfc4x2::IfcProfileTypeEnum nullEnum = OdIfc4x2::kIfcProfileTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcProjectOrderTypeEnum& getUnset() { static OdIfc4x2::IfcProjectOrderTypeEnum nullEnum = OdIfc4x2::kIfcProjectOrderTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcProjectedOrTrueLengthEnum& getUnset() { static OdIfc4x2::IfcProjectedOrTrueLengthEnum nullEnum = OdIfc4x2::kIfcProjectedOrTrueLengthEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration defines the basic types of projection elements. */ enum IfcProjectionElementTypeEnum { /** Part of concrete where the anchor for pre-stressing tendon can be embedded.*/ kIfcProjectionElementTypeEnum_BLISTER, /** Part of concrete where re-direction of an external pre-stressed tendon can be embedded.*/ kIfcProjectionElementTypeEnum_DEVIATOR, /** User-defined projection element.*/ kIfcProjectionElementTypeEnum_USERDEFINED, /** Undefined projection element.*/ kIfcProjectionElementTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcProjectionElementTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcProjectionElementTypeEnum& getUnset() { static OdIfc4x2::IfcProjectionElementTypeEnum nullEnum = OdIfc4x2::kIfcProjectionElementTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration defines the general applicability of instances of IfcPropertySet, or IfcElementQuantity defined by this IfcPropertySetTemplate, to subtypes of IfcObjectDefinition. */ enum IfcPropertySetTemplateTypeEnum { /** The property sets defined by this IfcPropertySetTemplate can only be assigned to subtypes of IfcTypeObject.*/ kIfcPropertySetTemplateTypeEnum_PSET_TYPEDRIVENONLY, /** The property sets defined by this IfcPropertySetTemplate can be assigned to subtypes of IfcTypeObject and can be overridden by a property set with same name at subtypes of IfcObject.*/ kIfcPropertySetTemplateTypeEnum_PSET_TYPEDRIVENOVERRIDE, /** The property sets defined by this IfcPropertySetTemplate can only be assigned to subtypes of IfcObject.*/ kIfcPropertySetTemplateTypeEnum_PSET_OCCURRENCEDRIVEN, /** The property sets defined by this IfcPropertySetTemplate can only be assigned to IfcPerformanceHistory, which is related to the applicable object by means of IfcRelAssignsToControl.*/ kIfcPropertySetTemplateTypeEnum_PSET_PERFORMANCEDRIVEN, /** The element quantity defined by this IfcPropertySetTemplate can only be assigned to subtypes of IfcTypeObject.*/ kIfcPropertySetTemplateTypeEnum_QTO_TYPEDRIVENONLY, /** The element quantity defined by this IfcPropertySetTemplate can be assigned to subtypes of IfcTypeObject and can be overridden by an element quantity with same name at subtypes of IfcObject.*/ kIfcPropertySetTemplateTypeEnum_QTO_TYPEDRIVENOVERRIDE, /** The element quantity defined by this IfcPropertySetTemplate can only be assigned to subtypes of IfcObject.*/ kIfcPropertySetTemplateTypeEnum_QTO_OCCURRENCEDRIVEN, /** No restriction provided, the property sets defined by this IfcPropertySetTemplate can be assigned to any entity, if not otherwise restricted by the ApplicableEntity attribute.*/ kIfcPropertySetTemplateTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcPropertySetTemplateTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcPropertySetTemplateTypeEnum& getUnset() { static OdIfc4x2::IfcPropertySetTemplateTypeEnum nullEnum = OdIfc4x2::kIfcPropertySetTemplateTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details Defines the range of different tripping unit types that can be used in conjunction with a protective device. */ enum IfcProtectiveDeviceTrippingUnitTypeEnum { /** A tripping unit activated by electronic action.*/ kIfcProtectiveDeviceTrippingUnitTypeEnum_ELECTRONIC, /** A tripping unit activated by electromagnetic action.*/ kIfcProtectiveDeviceTrippingUnitTypeEnum_ELECTROMAGNETIC, /** A tripping unit activated by residual current detection.*/ kIfcProtectiveDeviceTrippingUnitTypeEnum_RESIDUALCURRENT, /** A tripping unit activated by thermal action.*/ kIfcProtectiveDeviceTrippingUnitTypeEnum_THERMAL, /** User-defined type.*/ kIfcProtectiveDeviceTrippingUnitTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcProtectiveDeviceTrippingUnitTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcProtectiveDeviceTrippingUnitTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcProtectiveDeviceTrippingUnitTypeEnum& getUnset() { static OdIfc4x2::IfcProtectiveDeviceTrippingUnitTypeEnum nullEnum = OdIfc4x2::kIfcProtectiveDeviceTrippingUnitTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 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, /** A device that opens, closes, or isolates a circuit and has short circuit protection but no overload protection. It attempts to break the circuit when there is a leakage of current from phase to earth, by measuring voltage on the earth conductor.*/ kIfcProtectiveDeviceTypeEnum_EARTHLEAKAGECIRCUITBREAKER, /** A safety device used to open or close a circuit when there is no current. Used to isolate a part of a circuit, a machine, a part of an overhead line or an underground line so that maintenance can be safely conducted.*/ kIfcProtectiveDeviceTypeEnum_EARTHINGSWITCH, /** A device that will electrically open the circuit after a period of prolonged, abnormal current flow.*/ kIfcProtectiveDeviceTypeEnum_FUSEDISCONNECTOR, /** 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 OdIfc4x2::IfcProtectiveDeviceTypeEnum& getUnset() { static OdIfc4x2::IfcProtectiveDeviceTypeEnum nullEnum = OdIfc4x2::kIfcProtectiveDeviceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 pump designed to be immersed in a fluid, typically a collection tank.*/ kIfcPumpTypeEnum_SUBMERSIBLEPUMP, /** A pump designed to sit above a collection tank with a suction inlet extending into the tank.*/ kIfcPumpTypeEnum_SUMPPUMP, /** 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 OdIfc4x2::IfcPumpTypeEnum& getUnset() { static OdIfc4x2::IfcPumpTypeEnum nullEnum = OdIfc4x2::kIfcPumpTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcRailingTypeEnum& getUnset() { static OdIfc4x2::IfcRailingTypeEnum nullEnum = OdIfc4x2::kIfcRailingTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcRampFlightTypeEnum& getUnset() { static OdIfc4x2::IfcRampFlightTypeEnum nullEnum = OdIfc4x2::kIfcRampFlightTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcRampTypeEnum& getUnset() { static OdIfc4x2::IfcRampTypeEnum nullEnum = OdIfc4x2::kIfcRampTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details IfcRecurrenceTypeEnum enumerates the recurring pattern type, with valid combinations as indicated. */ enum IfcRecurrenceTypeEnum { /** Interval, Occurrences*/ kIfcRecurrenceTypeEnum_DAILY, /** WeekdayComponent, Interval, Occurrences*/ kIfcRecurrenceTypeEnum_WEEKLY, /** DayComponent, Interval, Occurrences*/ kIfcRecurrenceTypeEnum_MONTHLY_BY_DAY_OF_MONTH, /** WeekdayComponent, Position, Interval, Occurrences*/ kIfcRecurrenceTypeEnum_MONTHLY_BY_POSITION, /** Interval, Occurrences*/ kIfcRecurrenceTypeEnum_BY_DAY_COUNT, /** WeekdayComponent, Interval, Occurrences*/ kIfcRecurrenceTypeEnum_BY_WEEKDAY_COUNT, /** DayComponent, MonthComponent, Interval, Occurrences*/ kIfcRecurrenceTypeEnum_YEARLY_BY_DAY_OF_MONTH, /** WeekdayComponent, MonthComponent, Position, Interval, Occurrences*/ kIfcRecurrenceTypeEnum_YEARLY_BY_POSITION, /** The value is unset.*/ kIfcRecurrenceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcRecurrenceTypeEnum& getUnset() { static OdIfc4x2::IfcRecurrenceTypeEnum nullEnum = OdIfc4x2::kIfcRecurrenceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration defines the different types of referents. */ enum IfcReferentTypeEnum { /** Kilo point*/ kIfcReferentTypeEnum_KILOPOINT, /** Mile point*/ kIfcReferentTypeEnum_MILEPOINT, /** Station*/ kIfcReferentTypeEnum_STATION, /** User defined.*/ kIfcReferentTypeEnum_USERDEFINED, /** Undefined.*/ kIfcReferentTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcReferentTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcReferentTypeEnum& getUnset() { static OdIfc4x2::IfcReferentTypeEnum nullEnum = OdIfc4x2::kIfcReferentTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcReflectanceMethodEnum& getUnset() { static OdIfc4x2::IfcReflectanceMethodEnum nullEnum = OdIfc4x2::kIfcReflectanceMethodEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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, /** Anchoring reinforcement.*/ kIfcReinforcingBarRoleEnum_ANCHORING, /** 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 OdIfc4x2::IfcReinforcingBarRoleEnum& getUnset() { static OdIfc4x2::IfcReinforcingBarRoleEnum nullEnum = OdIfc4x2::kIfcReinforcingBarRoleEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcReinforcingBarSurfaceEnum& getUnset() { static OdIfc4x2::IfcReinforcingBarSurfaceEnum nullEnum = OdIfc4x2::kIfcReinforcingBarSurfaceEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 IfcReinforcingBarTypeEnum { /** Anchoring reinforcement.*/ kIfcReinforcingBarTypeEnum_ANCHORING, /** Edge reinforcement.*/ kIfcReinforcingBarTypeEnum_EDGE, /** The reinforcing bar is a ligature (link, stirrup).*/ kIfcReinforcingBarTypeEnum_LIGATURE, /** The reinforcing bar is a main bar.*/ kIfcReinforcingBarTypeEnum_MAIN, /** Punching reinforcement.*/ kIfcReinforcingBarTypeEnum_PUNCHING, /** Ring reinforcement.*/ kIfcReinforcingBarTypeEnum_RING, /** The reinforcing bar is a shear bar.*/ kIfcReinforcingBarTypeEnum_SHEAR, /** The reinforcing bar is a stud.*/ kIfcReinforcingBarTypeEnum_STUD, /** A stirrup in pre-stressing system to position TendonConduit.*/ kIfcReinforcingBarTypeEnum_SPACEBAR, /** The type of reinforcement is user defined.*/ kIfcReinforcingBarTypeEnum_USERDEFINED, /** The type of reinforcement is not defined.*/ kIfcReinforcingBarTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcReinforcingBarTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcReinforcingBarTypeEnum& getUnset() { static OdIfc4x2::IfcReinforcingBarTypeEnum nullEnum = OdIfc4x2::kIfcReinforcingBarTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details Enumeration defining the reinforcing mesh type. */ enum IfcReinforcingMeshTypeEnum { /** The type of mesh is user defined.*/ kIfcReinforcingMeshTypeEnum_USERDEFINED, /** The type of mesh is not defined.*/ kIfcReinforcingMeshTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcReinforcingMeshTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcReinforcingMeshTypeEnum& getUnset() { static OdIfc4x2::IfcReinforcingMeshTypeEnum nullEnum = OdIfc4x2::kIfcReinforcingMeshTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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_COMMISSIONINGENGINEER, /** 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 OdIfc4x2::IfcRoleEnum& getUnset() { static OdIfc4x2::IfcRoleEnum nullEnum = OdIfc4x2::kIfcRoleEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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_USERDEFINED, /** No specification given.*/ kIfcRoofTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcRoofTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcRoofTypeEnum& getUnset() { static OdIfc4x2::IfcRoofTypeEnum nullEnum = OdIfc4x2::kIfcRoofTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcSIPrefix& getUnset() { static OdIfc4x2::IfcSIPrefix nullEnum = OdIfc4x2::kIfcSIPrefix_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcSIUnitName& getUnset() { static OdIfc4x2::IfcSIUnitName nullEnum = OdIfc4x2::kIfcSIUnitName_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcSanitaryTerminalTypeEnum& getUnset() { static OdIfc4x2::IfcSanitaryTerminalTypeEnum nullEnum = OdIfc4x2::kIfcSanitaryTerminalTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcSectionTypeEnum& getUnset() { static OdIfc4x2::IfcSectionTypeEnum nullEnum = OdIfc4x2::kIfcSectionTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details The IfcSensorTypeEnum defines the range of different types of sensor that can be specified. */ enum IfcSensorTypeEnum { /** A device that senses or detects carbon monoxide.*/ kIfcSensorTypeEnum_COSENSOR, /** A device that senses or detects carbon dioxide.*/ kIfcSensorTypeEnum_CO2SENSOR, /** A device that senses or detects electrical conductance.*/ kIfcSensorTypeEnum_CONDUCTANCESENSOR, /** A device that senses or detects contact, such as for detecting if a door is closed.*/ kIfcSensorTypeEnum_CONTACTSENSOR, /** 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 frost on a window.*/ kIfcSensorTypeEnum_FROSTSENSOR, /** 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 reads a tag, such as for gaining access to a door or elevator*/ kIfcSensorTypeEnum_IDENTIFIERSENSOR, /** A device that senses or detects ion concentration, such as for water hardness.*/ kIfcSensorTypeEnum_IONCONCENTRATIONSENSOR, /** A device that senses or detects fill level, such as for a tank.*/ kIfcSensorTypeEnum_LEVELSENSOR, /** 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 acidity.*/ kIfcSensorTypeEnum_PHSENSOR, /** A device that senses or detects pressure.*/ kIfcSensorTypeEnum_PRESSURESENSOR, /** A device that senses or detects pressure.*/ kIfcSensorTypeEnum_RADIATIONSENSOR, /** A device that senses or detects atomic decay.*/ kIfcSensorTypeEnum_RADIOACTIVITYSENSOR, /** 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, /** A device that senses or detects airflow speed and direction.*/ kIfcSensorTypeEnum_WINDSENSOR, /** User-defined type.*/ kIfcSensorTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcSensorTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcSensorTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcSensorTypeEnum& getUnset() { static OdIfc4x2::IfcSensorTypeEnum nullEnum = OdIfc4x2::kIfcSensorTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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, /** User defined.*/ kIfcSequenceEnum_USERDEFINED, /** Undefined.*/ kIfcSequenceEnum_NOTDEFINED, /** The value is unset.*/ kIfcSequenceEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcSequenceEnum& getUnset() { static OdIfc4x2::IfcSequenceEnum nullEnum = OdIfc4x2::kIfcSequenceEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration defines the valid types of IfcShadingDevice or IfcShadingDeviceType that can be predefined using the enumeration values. */ enum IfcShadingDeviceTypeEnum { /** A blind with adjustable horizontal slats for admitting light and air while excluding direct sun and rain.*/ kIfcShadingDeviceTypeEnum_JALOUSIE, /** A mechanical device that limits the passage of light. Often used as a a solid or louvered movable cover for a window.*/ kIfcShadingDeviceTypeEnum_SHUTTER, /** A rooflike shelter of canvas or other material extending over a doorway, from the top of a window, over a deck, or similar, in order to provide protection, as from the sun.*/ kIfcShadingDeviceTypeEnum_AWNING, /** No description available.*/ kIfcShadingDeviceTypeEnum_USERDEFINED, /** No description available.*/ kIfcShadingDeviceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcShadingDeviceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcShadingDeviceTypeEnum& getUnset() { static OdIfc4x2::IfcShadingDeviceTypeEnum nullEnum = OdIfc4x2::kIfcShadingDeviceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration defines the correct subtype of instances of IfcSimpleProperty or IfcPhysicalSimpleQuantity that are created and are assigned to this IfcSimplePropertyTemplate. It also determines how the attributes of IfcPropertyTemplate, PrimaryUnit, SecondaryUnit, Enumerators, PrimaryDataType, SecondaryDataType, should be used. */ enum IfcSimplePropertyTemplateTypeEnum { /** The properties defined by this IfcPropertyTemplate are of type IfcPropertySingleValue.*/ kIfcSimplePropertyTemplateTypeEnum_P_SINGLEVALUE, /** The properties defined by this IfcPropertyTemplate are of type IfcPropertyEnumeratedValue.*/ kIfcSimplePropertyTemplateTypeEnum_P_ENUMERATEDVALUE, /** The properties defined by this IfcPropertyTemplate are of type IfcPropertyBoundedValue.*/ kIfcSimplePropertyTemplateTypeEnum_P_BOUNDEDVALUE, /** The properties defined by this IfcPropertyTemplate are of type IfcPropertyListValue.*/ kIfcSimplePropertyTemplateTypeEnum_P_LISTVALUE, /** The properties defined by this IfcPropertyTemplate are of type IfcPropertyTableValue.*/ kIfcSimplePropertyTemplateTypeEnum_P_TABLEVALUE, /** The properties defined by this IfcPropertyTemplate are of type IfcPropertyReferenceValue.*/ kIfcSimplePropertyTemplateTypeEnum_P_REFERENCEVALUE, /** The properties defined by this IfcPropertyTemplate are of type IfcQuantityLength.*/ kIfcSimplePropertyTemplateTypeEnum_Q_LENGTH, /** The properties defined by this IfcPropertyTemplate are of type IfcQuantityArea.*/ kIfcSimplePropertyTemplateTypeEnum_Q_AREA, /** The properties defined by this IfcPropertyTemplate are of type IfcQuantityVolume.*/ kIfcSimplePropertyTemplateTypeEnum_Q_VOLUME, /** The properties defined by this IfcPropertyTemplate are of type IfcQuantityCount.*/ kIfcSimplePropertyTemplateTypeEnum_Q_COUNT, /** The properties defined by this IfcPropertyTemplate are of type IfcQuantityWeight.*/ kIfcSimplePropertyTemplateTypeEnum_Q_WEIGHT, /** The properties defined by this IfcPropertyTemplate are of type IfcQuantityNumber.*/ kIfcSimplePropertyTemplateTypeEnum_Q_TIME, /** The value is unset.*/ kIfcSimplePropertyTemplateTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcSimplePropertyTemplateTypeEnum& getUnset() { static OdIfc4x2::IfcSimplePropertyTemplateTypeEnum nullEnum = OdIfc4x2::kIfcSimplePropertyTemplateTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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, /** Iis part of bridge abutment providing transition from embankment to the bridge*/ kIfcSlabTypeEnum_APPROACH_SLAB, /** Rigid pavement course of a road or other paved area, usually concrete.*/ kIfcSlabTypeEnum_PAVING, /** The slab is used to represent a wearing surface.*/ kIfcSlabTypeEnum_WEARING, /** The slab is used to represent a sidewalk.*/ kIfcSlabTypeEnum_SIDEWALK, /** No description available.*/ kIfcSlabTypeEnum_USERDEFINED, /** No description available.*/ kIfcSlabTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcSlabTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcSlabTypeEnum& getUnset() { static OdIfc4x2::IfcSlabTypeEnum nullEnum = OdIfc4x2::kIfcSlabTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details The IfcSolarDeviceTypeEnum defines different types of solar devices. */ enum IfcSolarDeviceTypeEnum { /** A device that converts solar radiation into thermal energy (heating water, etc.).*/ kIfcSolarDeviceTypeEnum_SOLARCOLLECTOR, /** A device that converts solar radiation into electric current.*/ kIfcSolarDeviceTypeEnum_SOLARPANEL, /** User-defined type.*/ kIfcSolarDeviceTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcSolarDeviceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcSolarDeviceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcSolarDeviceTypeEnum& getUnset() { static OdIfc4x2::IfcSolarDeviceTypeEnum nullEnum = OdIfc4x2::kIfcSolarDeviceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details Enumeration defining the functional type of space heater. */ enum IfcSpaceHeaterTypeEnum { /** A heat-distributing unit that operates with gravity-circulated air.*/ kIfcSpaceHeaterTypeEnum_CONVECTOR, /** A heat-distributing unit that operates with thermal radiation.*/ kIfcSpaceHeaterTypeEnum_RADIATOR, /** 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 OdIfc4x2::IfcSpaceHeaterTypeEnum& getUnset() { static OdIfc4x2::IfcSpaceHeaterTypeEnum nullEnum = OdIfc4x2::kIfcSpaceHeaterTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration defines the available generic types for IfcSpace and IfcSpaceType. */ enum IfcSpaceTypeEnum { /** Any space not falling into another category.*/ kIfcSpaceTypeEnum_SPACE, /** A space dedication for use as a parking spot for vehicles, including access, such as a parking aisle.*/ kIfcSpaceTypeEnum_PARKING, /** Gross Floor Area - a specific kind of space for each building story that includes all net area and construction area (also the external envelop). Provision of such a specific space is often required by regulations.*/ kIfcSpaceTypeEnum_GFA, /** A space inside a facility.*/ kIfcSpaceTypeEnum_INTERNAL, /** A space outside of a facility.*/ kIfcSpaceTypeEnum_EXTERNAL, /** No description available.*/ kIfcSpaceTypeEnum_USERDEFINED, /** No description available.*/ kIfcSpaceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcSpaceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcSpaceTypeEnum& getUnset() { static OdIfc4x2::IfcSpaceTypeEnum nullEnum = OdIfc4x2::kIfcSpaceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration defines the range of different types of spatial zones that can further specify an IfcSpatialZone. */ enum IfcSpatialZoneTypeEnum { /** The spatial zone is used to represent a construction zone for the production process.*/ kIfcSpatialZoneTypeEnum_CONSTRUCTION, /** The spatial zone is used to represent a fire safety zone, or fire compartment.*/ kIfcSpatialZoneTypeEnum_FIRESAFETY, /** The spatial zone is used to represent a lighting zone; a daylight zone, or an artificial lighting zone.*/ kIfcSpatialZoneTypeEnum_LIGHTING, /** The spatial zone is used to represent a zone of particular occupancy.*/ kIfcSpatialZoneTypeEnum_OCCUPANCY, /** The spatial zone is used to represent a zone for security planning and maintenance work.*/ kIfcSpatialZoneTypeEnum_SECURITY, /** The spatial zone is used to represent a thermal zone.*/ kIfcSpatialZoneTypeEnum_THERMAL, /** The spatial zone is used to represent an area primarily dedicated to the movement of people or goods.*/ kIfcSpatialZoneTypeEnum_TRANSPORT, /** The spatial zone is used to represent a ventilation zone.*/ kIfcSpatialZoneTypeEnum_VENTILATION, /** User defined type spatial zone.*/ kIfcSpatialZoneTypeEnum_USERDEFINED, /** Undefined type spatial zone.*/ kIfcSpatialZoneTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcSpatialZoneTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcSpatialZoneTypeEnum& getUnset() { static OdIfc4x2::IfcSpatialZoneTypeEnum nullEnum = OdIfc4x2::kIfcSpatialZoneTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcStackTerminalTypeEnum& getUnset() { static OdIfc4x2::IfcStackTerminalTypeEnum nullEnum = OdIfc4x2::kIfcStackTerminalTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcStairFlightTypeEnum& getUnset() { static OdIfc4x2::IfcStairFlightTypeEnum nullEnum = OdIfc4x2::kIfcStairFlightTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcStairTypeEnum& getUnset() { static OdIfc4x2::IfcStairTypeEnum nullEnum = OdIfc4x2::kIfcStairTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcStateEnum& getUnset() { static OdIfc4x2::IfcStateEnum nullEnum = OdIfc4x2::kIfcStateEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration defines the distribution of load values in a curve action or reaction. */ enum IfcStructuralCurveActivityTypeEnum { /** The load has a constant value over its entire extent.*/ kIfcStructuralCurveActivityTypeEnum_CONST, /** The load value is linearly distributed over the load's extent.*/ kIfcStructuralCurveActivityTypeEnum_LINEAR, /** The load consists of several consecutive linear sections.*/ kIfcStructuralCurveActivityTypeEnum_POLYGONAL, /** The load consists of n consecutive sections of same length and is specified by n+1 load samples. The interpolation type over the segments is not defined by this distribution type but may be qualified in IfcObject.ObjectType based on additional agreements.*/ kIfcStructuralCurveActivityTypeEnum_EQUIDISTANT, /** The load value is distributed as a sinus half wave.*/ kIfcStructuralCurveActivityTypeEnum_SINUS, /** The load value is distributed as a half wave described by a symmetric quadratic parabola.*/ kIfcStructuralCurveActivityTypeEnum_PARABOLA, /** The load is specified as a series of discrete load points.*/ kIfcStructuralCurveActivityTypeEnum_DISCRETE, /** The load distribution is user-defined.*/ kIfcStructuralCurveActivityTypeEnum_USERDEFINED, /** The load distribution is undefined.*/ kIfcStructuralCurveActivityTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcStructuralCurveActivityTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcStructuralCurveActivityTypeEnum& getUnset() { static OdIfc4x2::IfcStructuralCurveActivityTypeEnum nullEnum = OdIfc4x2::kIfcStructuralCurveActivityTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration distinguishes between different types of structural 'curve' members, such as cables. */ enum IfcStructuralCurveMemberTypeEnum { /** A member with capacity to carry transverse and axial loads, i.e. a beam. Its actual joints may be rigid or pinned. Typically used in rigid frames.*/ kIfcStructuralCurveMemberTypeEnum_RIGID_JOINED_MEMBER, /** A member with capacity to carry axial loads only, i.e. a link. Typically used in trusses.*/ kIfcStructuralCurveMemberTypeEnum_PIN_JOINED_MEMBER, /** A tension member which is able to carry transverse loads only under large deflection.*/ kIfcStructuralCurveMemberTypeEnum_CABLE, /** A member without compressional stiffness.*/ kIfcStructuralCurveMemberTypeEnum_TENSION_MEMBER, /** A member without tensional stiffness.*/ kIfcStructuralCurveMemberTypeEnum_COMPRESSION_MEMBER, /** A specially defined member.*/ kIfcStructuralCurveMemberTypeEnum_USERDEFINED, /** A member without further categorization.*/ kIfcStructuralCurveMemberTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcStructuralCurveMemberTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcStructuralCurveMemberTypeEnum& getUnset() { static OdIfc4x2::IfcStructuralCurveMemberTypeEnum nullEnum = OdIfc4x2::kIfcStructuralCurveMemberTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration defines the distribution of load values in a surface action or reaction. */ enum IfcStructuralSurfaceActivityTypeEnum { /** The load has a constant value over its entire extent.*/ kIfcStructuralSurfaceActivityTypeEnum_CONST, /** The load value is bilinearly distributed over the load's extent.*/ kIfcStructuralSurfaceActivityTypeEnum_BILINEAR, /** The load is specified as a series of discrete load points.*/ kIfcStructuralSurfaceActivityTypeEnum_DISCRETE, /** The load is specified by a series of iso-curves (level sets), i.e. curves at which the load value is constant. These curves run perpendicularly to the load gradient.*/ kIfcStructuralSurfaceActivityTypeEnum_ISOCONTOUR, /** The load distribution is user-defined.*/ kIfcStructuralSurfaceActivityTypeEnum_USERDEFINED, /** The load distribution is undefined.*/ kIfcStructuralSurfaceActivityTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcStructuralSurfaceActivityTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcStructuralSurfaceActivityTypeEnum& getUnset() { static OdIfc4x2::IfcStructuralSurfaceActivityTypeEnum nullEnum = OdIfc4x2::kIfcStructuralSurfaceActivityTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration distinguishes between different types of structural surface members, such as the typical mechanical function of walls, slabs and shells. */ enum IfcStructuralSurfaceMemberTypeEnum { /** A member with capacity to carry out-of-plane loads, i.e. a plate.*/ kIfcStructuralSurfaceMemberTypeEnum_BENDING_ELEMENT, /** A member with capacity to carry in-plane loads, for example a shear wall.*/ kIfcStructuralSurfaceMemberTypeEnum_MEMBRANE_ELEMENT, /** A member with capacity to carry in-plane and out-of-plane loads, i.e. a combination of bending element and membrane element.*/ kIfcStructuralSurfaceMemberTypeEnum_SHELL, /** A specially defined member.*/ kIfcStructuralSurfaceMemberTypeEnum_USERDEFINED, /** A member without further categorization.*/ kIfcStructuralSurfaceMemberTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcStructuralSurfaceMemberTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcStructuralSurfaceMemberTypeEnum& getUnset() { static OdIfc4x2::IfcStructuralSurfaceMemberTypeEnum nullEnum = OdIfc4x2::kIfcStructuralSurfaceMemberTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration is used to identify the primary purpose of a subcontract resource. */ enum IfcSubContractResourceTypeEnum { /** Furnishing or supplying products.*/ kIfcSubContractResourceTypeEnum_PURCHASE, /** Performing work onsite.*/ kIfcSubContractResourceTypeEnum_WORK, /** User-defined resource.*/ kIfcSubContractResourceTypeEnum_USERDEFINED, /** Undefined resource.*/ kIfcSubContractResourceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcSubContractResourceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcSubContractResourceTypeEnum& getUnset() { static OdIfc4x2::IfcSubContractResourceTypeEnum nullEnum = OdIfc4x2::kIfcSubContractResourceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration indicates the type of a surface feature. */ enum IfcSurfaceFeatureTypeEnum { /** A point, line, cross, or other mark, applied for example for easier adjustment of elements during assembly.*/ kIfcSurfaceFeatureTypeEnum_MARK, /** A name tag, which allows to identify an element during production, delivery and assembly. May be manufactured in different ways, e.g. by printing or punching the tracking code onto the element or by attaching an actual tag.*/ kIfcSurfaceFeatureTypeEnum_TAG, /** A subtractive surface feature, e.g. grinding, or an additive surface feature, e.g. coating, or an impregnating treatment, or a series of any of these kinds of treatments.*/ kIfcSurfaceFeatureTypeEnum_TREATMENT, /** Detected defect on the surface of an element, such as corroded or eroded area.*/ kIfcSurfaceFeatureTypeEnum_DEFECT, /** A user-defined type of surface feature.*/ kIfcSurfaceFeatureTypeEnum_USERDEFINED, /** An undefined type of surface feature.*/ kIfcSurfaceFeatureTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcSurfaceFeatureTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcSurfaceFeatureTypeEnum& getUnset() { static OdIfc4x2::IfcSurfaceFeatureTypeEnum nullEnum = OdIfc4x2::kIfcSurfaceFeatureTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcSurfaceSide& getUnset() { static OdIfc4x2::IfcSurfaceSide nullEnum = OdIfc4x2::kIfcSurfaceSide_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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, /** A dimmer switch has variable positions, and may adjust electrical power or other setting (according to the switched port type).*/ kIfcSwitchingDeviceTypeEnum_DIMMERSWITCH, /** An emergency stop device acts to remove as quickly as possible any danger that may have arisen unexpectedly.*/ kIfcSwitchingDeviceTypeEnum_EMERGENCYSTOP, /** A set of buttons or switches, each potentially applicable to a different device.*/ kIfcSwitchingDeviceTypeEnum_KEYPAD, /** A momentary switch has no position, and may trigger some action to occur.*/ kIfcSwitchingDeviceTypeEnum_MOMENTARYSWITCH, /** A selector switch has multiple positions, and may change the source or level of power or other setting (according to the switched port type).*/ kIfcSwitchingDeviceTypeEnum_SELECTORSWITCH, /** 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 OdIfc4x2::IfcSwitchingDeviceTypeEnum& getUnset() { static OdIfc4x2::IfcSwitchingDeviceTypeEnum nullEnum = OdIfc4x2::kIfcSwitchingDeviceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details IfcSystemFurnitureElementTypeEnum defines the types of system furniture from which the type required can be selected. */ enum IfcSystemFurnitureElementTypeEnum { /** Vertical panel used to divide work spaces.*/ kIfcSystemFurnitureElementTypeEnum_PANEL, /** Workstation countertop.*/ kIfcSystemFurnitureElementTypeEnum_WORKSURFACE, /** User-defined type.*/ kIfcSystemFurnitureElementTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcSystemFurnitureElementTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcSystemFurnitureElementTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcSystemFurnitureElementTypeEnum& getUnset() { static OdIfc4x2::IfcSystemFurnitureElementTypeEnum nullEnum = OdIfc4x2::kIfcSystemFurnitureElementTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details Enumeration defining the typical types of tanks. */ enum IfcTankTypeEnum { /** An arbitrary open tank type.*/ kIfcTankTypeEnum_BASIN, /** An open container that breaks the hydraulic pressure in a distribution system, typically located between the fluid reservoir and the fluid supply points. A typical break pressure tank allows the flow to discharge into the atmosphere, thereby reducing its hydrostatic pressure to zero.*/ kIfcTankTypeEnum_BREAKPRESSURE, /** 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, /** An open tank that is used for both storage and thermal expansion. A typical example is a tank used to store make-up water at ambient pressure for supply to a hot water system, simultaneously accommodating increases in volume of the water when heated.*/ kIfcTankTypeEnum_FEEDANDEXPANSION, /** 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, /** An open or closed container used for storing a fluid at ambient pressure and from which it can be supplied to the fluid distribution system. There are many examples of storage tanks, such as potable water storage tanks, fuel storage tanks, etc.*/ kIfcTankTypeEnum_STORAGE, /** An arbitrary closed tank type.*/ kIfcTankTypeEnum_VESSEL, /** User-defined tank type.*/ kIfcTankTypeEnum_USERDEFINED, /** Undefined tank type.*/ kIfcTankTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcTankTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcTankTypeEnum& getUnset() { static OdIfc4x2::IfcTankTypeEnum nullEnum = OdIfc4x2::kIfcTankTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details IfcTaskDurationEnum identifies how a time duration is measured. */ enum IfcTaskDurationEnum { /** The time duration is based on elapsed time (24 hours per day, independent of calendar).*/ kIfcTaskDurationEnum_ELAPSEDTIME, /** The time duration is based on work time (calendar-dependent).*/ kIfcTaskDurationEnum_WORKTIME, /** The time duration is undefined.*/ kIfcTaskDurationEnum_NOTDEFINED, /** The value is unset.*/ kIfcTaskDurationEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcTaskDurationEnum& getUnset() { static OdIfc4x2::IfcTaskDurationEnum nullEnum = OdIfc4x2::kIfcTaskDurationEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details The IfcTaskTypeEnum defines the range of different types of task that can be specified. */ enum IfcTaskTypeEnum { /** Attendance or waiting on other things happening.*/ kIfcTaskTypeEnum_ATTENDANCE, /** Constructing or building something.*/ kIfcTaskTypeEnum_CONSTRUCTION, /** Demolishing or breaking down something.*/ kIfcTaskTypeEnum_DEMOLITION, /** Taking something apart carefully so that it can be recycled or reused.*/ kIfcTaskTypeEnum_DISMANTLE, /** Disposing or getting rid of something.*/ kIfcTaskTypeEnum_DISPOSAL, /** Installing something (equivalent to construction but more commonly used for engineering tasks).*/ kIfcTaskTypeEnum_INSTALLATION, /** Transportation or delivery of something.*/ kIfcTaskTypeEnum_LOGISTIC, /** Tasks required to keep an object in good working order.*/ kIfcTaskTypeEnum_MAINTENANCE, /** Moving things from one place to another.*/ kIfcTaskTypeEnum_MOVE, /** A procedure undertaken to start up the operation an artifact.*/ kIfcTaskTypeEnum_OPERATION, /** Removal of an item from use and taking it from its place of use.*/ kIfcTaskTypeEnum_REMOVAL, /** Bringing something to an 'as-new' state.*/ kIfcTaskTypeEnum_RENOVATION, /** User defined.*/ kIfcTaskTypeEnum_USERDEFINED, /** Undefined.*/ kIfcTaskTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcTaskTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcTaskTypeEnum& getUnset() { static OdIfc4x2::IfcTaskTypeEnum nullEnum = OdIfc4x2::kIfcTaskTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details Enumeration defining the types of tendon anchors. */ enum IfcTendonAnchorTypeEnum { /** The anchor is an intermediate device which connects two tendons.*/ kIfcTendonAnchorTypeEnum_COUPLER, /** The anchor fixes the end of a tendon.*/ kIfcTendonAnchorTypeEnum_FIXED_END, /** The anchor is used or can be used to prestress the tendon.*/ kIfcTendonAnchorTypeEnum_TENSIONING_END, /** The type of tendon anchor is user defined.*/ kIfcTendonAnchorTypeEnum_USERDEFINED, /** The type of tendon anchor is not defined.*/ kIfcTendonAnchorTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcTendonAnchorTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcTendonAnchorTypeEnum& getUnset() { static OdIfc4x2::IfcTendonAnchorTypeEnum nullEnum = OdIfc4x2::kIfcTendonAnchorTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details Enumerations of Tendon Conduit Types. */ enum IfcTendonConduitTypeEnum { /** A Sleeve or duct is related to the thickness of the conduit depending on the conduit, either cast into the concrete structure or placed adjacent to it.*/ kIfcTendonConduitTypeEnum_DUCT, /** A part to connect the conduits located in two different deck segments and related to the same tendon.*/ kIfcTendonConduitTypeEnum_COUPLER, /** An additional small conduit connected to the main conduit to allow grouting in case of bonded post-tensioning, such as Grout inlet, Grout outlet and Grout vent.*/ kIfcTendonConduitTypeEnum_GROUTING_DUCT, /** A specific part of conduit which has to be widened when reaching the tendon anchor because the strands are connected individually on the anchor.*/ kIfcTendonConduitTypeEnum_TRUMPET, /** A part of tendon conduit associated to deviator.*/ kIfcTendonConduitTypeEnum_DIABOLO, /** The type of tendon conduit is user defined.*/ kIfcTendonConduitTypeEnum_USERDEFINED, /** The type of tendon conduit is not defined.*/ kIfcTendonConduitTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcTendonConduitTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcTendonConduitTypeEnum& getUnset() { static OdIfc4x2::IfcTendonConduitTypeEnum nullEnum = OdIfc4x2::kIfcTendonConduitTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details Enumeration defining the types of tendons. */ enum IfcTendonTypeEnum { /** The tendon is configured as a bar.*/ kIfcTendonTypeEnum_BAR, /** The tendon is coated.*/ kIfcTendonTypeEnum_COATED, /** The tendon is a strand.*/ kIfcTendonTypeEnum_STRAND, /** The tendon is a wire.*/ kIfcTendonTypeEnum_WIRE, /** 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 OdIfc4x2::IfcTendonTypeEnum& getUnset() { static OdIfc4x2::IfcTendonTypeEnum nullEnum = OdIfc4x2::kIfcTendonTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcTextPath& getUnset() { static OdIfc4x2::IfcTextPath nullEnum = OdIfc4x2::kIfcTextPath_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcTimeSeriesDataTypeEnum& getUnset() { static OdIfc4x2::IfcTimeSeriesDataTypeEnum nullEnum = OdIfc4x2::kIfcTimeSeriesDataTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 converts from direct current (DC) to alternating current (AC).*/ kIfcTransformerTypeEnum_INVERTER, /** A transformer that converts from alternating current (AC) to direct current (DC).*/ kIfcTransformerTypeEnum_RECTIFIER, /** 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 OdIfc4x2::IfcTransformerTypeEnum& getUnset() { static OdIfc4x2::IfcTransformerTypeEnum nullEnum = OdIfc4x2::kIfcTransformerTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcTransitionCode& getUnset() { static OdIfc4x2::IfcTransitionCode nullEnum = OdIfc4x2::kIfcTransitionCode_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details The IfcTransitionCurveType indicates the curvature of a transition curve. Resulting Cartesian coordinates (relative to starting position and orientation) are given by equations herein, where l (lowercase) refers to the distance along the curve segment, L refers to the length of the curve segment (IfcCurveSegment2D.Length), and R refers to the radius at the circular end of the curve segment (e.g. IfcTransitionCurveSegment2D.EndRadius). */ enum IfcTransitionCurveType { /** BIQUADRATICPARABOLA*/ kIfcTransitionCurveType_BIQUADRATICPARABOLA, /** BLOSSCURVE*/ kIfcTransitionCurveType_BLOSSCURVE, /** CLOTHOIDCURVE*/ kIfcTransitionCurveType_CLOTHOIDCURVE, /** COSINECURVE*/ kIfcTransitionCurveType_COSINECURVE, /** CUBICPARABOLA*/ kIfcTransitionCurveType_CUBICPARABOLA, /** SINECURVE*/ kIfcTransitionCurveType_SINECURVE, /** The value is unset.*/ kIfcTransitionCurveType_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcTransitionCurveType& getUnset() { static OdIfc4x2::IfcTransitionCurveType nullEnum = OdIfc4x2::kIfcTransitionCurveType_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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, /** A crane way system, normally including the crane rails, fasteners and the crane. It is primarily used to move heavy goods in a factory or other industry buildings.*/ kIfcTransportElementTypeEnum_CRANEWAY, /** A device used for lifting or lowering heavy goods. It may be manually operated or electrically or pneumatically driven.*/ kIfcTransportElementTypeEnum_LIFTINGGEAR, /** User-defined type.*/ kIfcTransportElementTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcTransportElementTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcTransportElementTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcTransportElementTypeEnum& getUnset() { static OdIfc4x2::IfcTransportElementTypeEnum nullEnum = OdIfc4x2::kIfcTransportElementTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcTrimmingPreference& getUnset() { static OdIfc4x2::IfcTrimmingPreference nullEnum = OdIfc4x2::kIfcTrimmingPreference_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcTubeBundleTypeEnum& getUnset() { static OdIfc4x2::IfcTubeBundleTypeEnum nullEnum = OdIfc4x2::kIfcTubeBundleTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcUnitEnum& getUnset() { static OdIfc4x2::IfcUnitEnum nullEnum = OdIfc4x2::kIfcUnitEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details The IfcUnitaryControlElementTypeEnum defines the range of different types and/or functions of unitary control elements possible. */ enum IfcUnitaryControlElementTypeEnum { /** A control element at which alarms are annunciated.*/ kIfcUnitaryControlElementTypeEnum_ALARMPANEL, /** A control element at which devices that control or monitor the operation of a site, building or part of a building are located*/ kIfcUnitaryControlElementTypeEnum_CONTROLPANEL, /** A control element at which the detection of gas is annunciated.*/ kIfcUnitaryControlElementTypeEnum_GASDETECTIONPANEL, /** A control element at which equipment operational status, condition, safety state or other required parameters are indicated.*/ kIfcUnitaryControlElementTypeEnum_INDICATORPANEL, /** A control element at which information that is available elsewhere is repeated or 'mimicked'.*/ kIfcUnitaryControlElementTypeEnum_MIMICPANEL, /** A control element that senses and regulates the humidity of a system or space so that the humidity is maintained near a desired setpoint.*/ kIfcUnitaryControlElementTypeEnum_HUMIDISTAT, /** A control element that senses and regulates the temperature of an element, system or space so that the temperature is maintained near a desired setpoint.*/ kIfcUnitaryControlElementTypeEnum_THERMOSTAT, /** A control element that senses multiple climate properties such as temperature, humidity, pressure, wind, and rain.*/ kIfcUnitaryControlElementTypeEnum_WEATHERSTATION, /** User-defined type.*/ kIfcUnitaryControlElementTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcUnitaryControlElementTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcUnitaryControlElementTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcUnitaryControlElementTypeEnum& getUnset() { static OdIfc4x2::IfcUnitaryControlElementTypeEnum nullEnum = OdIfc4x2::kIfcUnitaryControlElementTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 unitary packaged dehumidification unit. Note: units supporting multiple modes (dehumidification, cooling, and/or heating) should use AIRCONDITIONINGUNIT.*/ kIfcUnitaryEquipmentTypeEnum_DEHUMIDIFIER, /** 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 OdIfc4x2::IfcUnitaryEquipmentTypeEnum& getUnset() { static OdIfc4x2::IfcUnitaryEquipmentTypeEnum nullEnum = OdIfc4x2::kIfcUnitaryEquipmentTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcValveTypeEnum& getUnset() { static OdIfc4x2::IfcValveTypeEnum nullEnum = OdIfc4x2::kIfcValveTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details Enumeration of Vibration Damper Types. */ enum IfcVibrationDamperTypeEnum { /** A displacement dependent type damper in which the resistance force generated is determined by the plastic strain amount utilizing the plastic deformation of the steel material. The bending yield type is a damper, which yields steel material by bending.*/ kIfcVibrationDamperTypeEnum_BENDING_YIELD, /** A displacement dependent type damper in which the resistance force generated is determined by the plastic strain amount utilizing the plastic deformation of the steel material. The shear yield type is a damper, which causes the steel material to yield for deformation in the direction perpendicular to the member.*/ kIfcVibrationDamperTypeEnum_SHEAR_YIELD, /** A displacement dependent type damper in which the resistance force generated is determined by the plastic strain amount utilizing the plastic deformation of the steel material. The axial yield type is a damper that yields energy by absorbing the steel material against deformation in the axial direction, that is, in the direction of expansion and contraction.*/ kIfcVibrationDamperTypeEnum_AXIAL_YIELD, /** The friction type is a damper utilizing friction acting on the contact surface of a material.*/ kIfcVibrationDamperTypeEnum_FRICTION, /** The viscous type is a damper that absorbs energy by utilizing the resistance of a viscous body.*/ kIfcVibrationDamperTypeEnum_VISCOUS, /** The rubber mold is a damper that absorbs energy by utilizing deformation of laminated rubber. The difference between the seismic isolation bearing and the rubber type damper is whether or not to support the weight of the upper structures. The rubber damper does not transmit the weight of the upper structures to the sub structure.*/ kIfcVibrationDamperTypeEnum_RUBBER, /** User-defined vibration damper type.*/ kIfcVibrationDamperTypeEnum_USERDEFINED, /** Undefined vibration damper type.*/ kIfcVibrationDamperTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcVibrationDamperTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcVibrationDamperTypeEnum& getUnset() { static OdIfc4x2::IfcVibrationDamperTypeEnum nullEnum = OdIfc4x2::kIfcVibrationDamperTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details Enumeration defining the typical types of vibration isolators. */ enum IfcVibrationIsolatorTypeEnum { /** Compression type vibration isolator.*/ kIfcVibrationIsolatorTypeEnum_COMPRESSION, /** Spring type vibration isolator.*/ kIfcVibrationIsolatorTypeEnum_SPRING, /** Base isolator preventing transfer of energy from the ground to the structure.*/ kIfcVibrationIsolatorTypeEnum_BASE, /** 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 OdIfc4x2::IfcVibrationIsolatorTypeEnum& getUnset() { static OdIfc4x2::IfcVibrationIsolatorTypeEnum nullEnum = OdIfc4x2::kIfcVibrationIsolatorTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration qualifies a voiding feature regarding its shape and configuration relative to the voided element. */ enum IfcVoidingFeatureTypeEnum { /** An internal cutout (creating an opening) or external cutout (creating a recess) of arbitrary shape. The edges between cutting planes may be overcut or undercut, i.e. rounded.*/ kIfcVoidingFeatureTypeEnum_CUTOUT, /** An external cutout of with a mostly rectangular cutting profile. The edges between cutting planes may be overcut or undercut, i.e. rounded.*/ kIfcVoidingFeatureTypeEnum_NOTCH, /** A circular or slotted or threaded hole, typically but not necessarily of smaller dimension than what would be considered a cutout.*/ kIfcVoidingFeatureTypeEnum_HOLE, /** A skewed plane end cut, removing material across the entire profile of the voided element.*/ kIfcVoidingFeatureTypeEnum_MITER, /** A skewed plane end cut, removing material only across a part of the profile of the voided element.*/ kIfcVoidingFeatureTypeEnum_CHAMFER, /** A shape modification along an edge of the element with the edge length as the predominant dimension of the feature, and feature profile dimensions which are typically much smaller than the edge length. Can for example be a chamfer edge (differentiated from a chamfer by its ratio of dimensions and thus usually manufactured differently), rounded edge (a convex edge feature), or fillet edge (a concave edge feature).*/ kIfcVoidingFeatureTypeEnum_EDGE, /** A user-defined type of voiding feature.*/ kIfcVoidingFeatureTypeEnum_USERDEFINED, /** An undefined type of voiding feature.*/ kIfcVoidingFeatureTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcVoidingFeatureTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcVoidingFeatureTypeEnum& getUnset() { static OdIfc4x2::IfcVoidingFeatureTypeEnum nullEnum = OdIfc4x2::kIfcVoidingFeatureTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration defines the different types of walls that can further specify an IfcWall or IfcWallType. */ enum IfcWallTypeEnum { /** A movable wall that is either movable, such as folding wall or a sliding wall, or can be easily removed as a removable partitioning or mounting wall. Movable walls do normally not define space boundaries and often belong to the furnishing system.*/ kIfcWallTypeEnum_MOVABLE, /** A wall-like barrier to protect human or vehicle from falling, or to prevent the spread of fires. Often designed at the edge of balconies, terraces or roofs, or along edges of bridges.*/ kIfcWallTypeEnum_PARAPET, /** A wall designed to partition spaces that often has a light-weight, sandwich-like construction (e.g. using gypsum board). Partitioning walls are normally non load bearing.*/ kIfcWallTypeEnum_PARTITIONING, /** 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, /** 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 massive wall construction for the wall core being the single layer or having multiple layers attached. Such walls are often masonry or concrete walls (both cast in-situ or precast) that are load bearing and fire protecting.*/ kIfcWallTypeEnum_SOLIDWALL, /** 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 stud wall framed with studs and faced with sheetings, sidings, wallboard, or plasterwork.*/ kIfcWallTypeEnum_ELEMENTEDWALL, /** A supporting wall used to protect against soil layers behind. Special types of a retaining wall may be e.g. Gabion wall and Grib wall. Examples of retaining walls are wing wall, headwall, stem wall, pierwall and protecting wall.*/ kIfcWallTypeEnum_RETAININGWALL, /** User-defined wall element.*/ kIfcWallTypeEnum_USERDEFINED, /** Undefined wall element.*/ kIfcWallTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcWallTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcWallTypeEnum& getUnset() { static OdIfc4x2::IfcWallTypeEnum nullEnum = OdIfc4x2::kIfcWallTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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, /** 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 OdIfc4x2::IfcWasteTerminalTypeEnum& getUnset() { static OdIfc4x2::IfcWasteTerminalTypeEnum nullEnum = OdIfc4x2::kIfcWasteTerminalTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcWindowPanelOperationEnum& getUnset() { static OdIfc4x2::IfcWindowPanelOperationEnum nullEnum = OdIfc4x2::kIfcWindowPanelOperationEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcWindowPanelPositionEnum& getUnset() { static OdIfc4x2::IfcWindowPanelPositionEnum nullEnum = OdIfc4x2::kIfcWindowPanelPositionEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcWindowStyleConstructionEnum& getUnset() { static OdIfc4x2::IfcWindowStyleConstructionEnum nullEnum = OdIfc4x2::kIfcWindowStyleConstructionEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 OdIfc4x2::IfcWindowStyleOperationEnum& getUnset() { static OdIfc4x2::IfcWindowStyleOperationEnum nullEnum = OdIfc4x2::kIfcWindowStyleOperationEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details This enumeration defines the different predefined types of windows that can further specify an IfcWindow or IfcWindowType. */ enum IfcWindowTypeEnum { /** A standard window usually within a wall opening, as a window panel in a curtain wall, or as a "free standing" window.*/ kIfcWindowTypeEnum_WINDOW, /** A window within a sloped building element, usually a roof slab.*/ kIfcWindowTypeEnum_SKYLIGHT, /** A special window that lies horizonally in a roof slab opening.*/ kIfcWindowTypeEnum_LIGHTDOME, /** User-defined window element.*/ kIfcWindowTypeEnum_USERDEFINED, /** Undefined window element.*/ kIfcWindowTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcWindowTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcWindowTypeEnum& getUnset() { static OdIfc4x2::IfcWindowTypeEnum nullEnum = OdIfc4x2::kIfcWindowTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \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 IfcWindowTypePartitioningEnum { /** Window with one panel.*/ kIfcWindowTypePartitioningEnum_SINGLE_PANEL, /** Window with two panels. The configuration of the panels is vertically.*/ kIfcWindowTypePartitioningEnum_DOUBLE_PANEL_VERTICAL, /** Window with two panels. The configuration of the panels is horizontally.*/ kIfcWindowTypePartitioningEnum_DOUBLE_PANEL_HORIZONTAL, /** Window with three panels. The configuration of the panels is vertically.*/ kIfcWindowTypePartitioningEnum_TRIPLE_PANEL_VERTICAL, /** Window with three panels. The configuration of two panels is vertically and the third one is horizontally at the bottom.*/ kIfcWindowTypePartitioningEnum_TRIPLE_PANEL_BOTTOM, /** Window with three panels. The configuration of two panels is vertically and the third one is horizontally at the top.*/ kIfcWindowTypePartitioningEnum_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.*/ kIfcWindowTypePartitioningEnum_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.*/ kIfcWindowTypePartitioningEnum_TRIPLE_PANEL_RIGHT, /** Window with three panels. The configuration of the panels is horizontally.*/ kIfcWindowTypePartitioningEnum_TRIPLE_PANEL_HORIZONTAL, /** User defined operation type.*/ kIfcWindowTypePartitioningEnum_USERDEFINED, /** No description available.*/ kIfcWindowTypePartitioningEnum_NOTDEFINED, /** The value is unset.*/ kIfcWindowTypePartitioningEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcWindowTypePartitioningEnum& getUnset() { static OdIfc4x2::IfcWindowTypePartitioningEnum nullEnum = OdIfc4x2::kIfcWindowTypePartitioningEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details An IfcWorkCalendarTypeEnum is an enumeration data type that specifies the types of work calendar from which the relevant control can be selected. If given it should help to identify base calendars. */ enum IfcWorkCalendarTypeEnum { /** Belongs to the first shift.*/ kIfcWorkCalendarTypeEnum_FIRSTSHIFT, /** Belongs to the second shift.*/ kIfcWorkCalendarTypeEnum_SECONDSHIFT, /** Belongs to the third shift.*/ kIfcWorkCalendarTypeEnum_THIRDSHIFT, /** User defined.*/ kIfcWorkCalendarTypeEnum_USERDEFINED, /** Undefined.*/ kIfcWorkCalendarTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcWorkCalendarTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcWorkCalendarTypeEnum& getUnset() { static OdIfc4x2::IfcWorkCalendarTypeEnum nullEnum = OdIfc4x2::kIfcWorkCalendarTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details An IfcWorkPlanTypeEnum is an enumeration data type that specifies the types of work plan from which the relevant control can be selected. */ enum IfcWorkPlanTypeEnum { /** A control in which actual items undertaken are indicated.*/ kIfcWorkPlanTypeEnum_ACTUAL, /** A control that is a baseline from which changes that are made later can be recognized.*/ kIfcWorkPlanTypeEnum_BASELINE, /** Planned*/ kIfcWorkPlanTypeEnum_PLANNED, /** User-defined*/ kIfcWorkPlanTypeEnum_USERDEFINED, /** Undefined.*/ kIfcWorkPlanTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcWorkPlanTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcWorkPlanTypeEnum& getUnset() { static OdIfc4x2::IfcWorkPlanTypeEnum nullEnum = OdIfc4x2::kIfcWorkPlanTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { /** \details An IfcWorkScheduleTypeEnum is an enumeration data type that specifies the types of work schedule from which the relevant process can be selected. */ enum IfcWorkScheduleTypeEnum { /** A process in which actual items undertaken are indicated.*/ kIfcWorkScheduleTypeEnum_ACTUAL, /** A process that is a baseline from which changes that are made later can be recognized.*/ kIfcWorkScheduleTypeEnum_BASELINE, /** A process showing planned items.*/ kIfcWorkScheduleTypeEnum_PLANNED, /** User-defined.*/ kIfcWorkScheduleTypeEnum_USERDEFINED, /** Undefined.*/ kIfcWorkScheduleTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcWorkScheduleTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x2::IfcWorkScheduleTypeEnum& getUnset() { static OdIfc4x2::IfcWorkScheduleTypeEnum nullEnum = OdIfc4x2::kIfcWorkScheduleTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x2 { } // namespace #include "TD_PackPop.h" #endif // _IFC4X2_ENUM_H