/////////////////////////////////////////////////////////////////////////////// // 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 _IFC4X4_ENUM_H #define _IFC4X4_ENUM_H #include "RxValue.h" #include "daiEnum.h" #include "IFC4X4BuildOption.h" #include "TD_PackPush.h" namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcActionRequestTypeEnum& getUnset() { static OdIfc4x4::IfcActionRequestTypeEnum nullEnum = OdIfc4x4::kIfcActionRequestTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration type contains possible action sources. */ enum IfcActionSourceTypeEnum { /** Brakes*/ kIfcActionSourceTypeEnum_BRAKES, /** Buoyancy.*/ kIfcActionSourceTypeEnum_BUOYANCY, /** Completion.*/ kIfcActionSourceTypeEnum_COMPLETION_G1, /** Forces due to creep.*/ kIfcActionSourceTypeEnum_CREEP, /** Current.*/ kIfcActionSourceTypeEnum_CURRENT, /** 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, /** Earthquake loads affect the design of structures in areas of great seismic activity.*/ kIfcActionSourceTypeEnum_EARTHQUAKE_E, /** Loads on the facility that occur during erection, but not after completion.*/ kIfcActionSourceTypeEnum_ERECTION, /** Fire action on the build facility.*/ kIfcActionSourceTypeEnum_FIRE, /** Loads from ice.*/ kIfcActionSourceTypeEnum_ICE, /** Impact force from an object hitting the facility.*/ kIfcActionSourceTypeEnum_IMPACT, /** Load from impulse force.*/ kIfcActionSourceTypeEnum_IMPULSE, /** Lack of fit.*/ kIfcActionSourceTypeEnum_LACK_OF_FIT, /** 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, /** Presstressing load.*/ kIfcActionSourceTypeEnum_PRESTRESSING_P, /** Propping*/ kIfcActionSourceTypeEnum_PROPPING, /** Rain and water on the structure.*/ kIfcActionSourceTypeEnum_RAIN, /** If one part of a building settles more than another part, then stresses are set up in the structures.*/ kIfcActionSourceTypeEnum_SETTLEMENT_U, /** Loads from shrinkage.*/ kIfcActionSourceTypeEnum_SHRINKAGE, /** 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, /** Loads from imperfections in the system.*/ kIfcActionSourceTypeEnum_SYSTEM_IMPERFECTION, /** 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, /** Loads from transport.*/ kIfcActionSourceTypeEnum_TRANSPORT, /** Loads from a wave hitting the structure.*/ kIfcActionSourceTypeEnum_WAVE, /** 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, /** 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 OdIfc4x4::IfcActionSourceTypeEnum& getUnset() { static OdIfc4x4::IfcActionSourceTypeEnum nullEnum = OdIfc4x4::kIfcActionSourceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 { /** Extraordinary A*/ kIfcActionTypeEnum_EXTRAORDINARY_A, /** Permanent G*/ kIfcActionTypeEnum_PERMANENT_G, /** Variable Q*/ kIfcActionTypeEnum_VARIABLE_Q, /** User defined*/ kIfcActionTypeEnum_USERDEFINED, /** Not defined*/ kIfcActionTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcActionTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcActionTypeEnum& getUnset() { static OdIfc4x4::IfcActionTypeEnum nullEnum = OdIfc4x4::kIfcActionTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcActuatorTypeEnum& getUnset() { static OdIfc4x4::IfcActuatorTypeEnum nullEnum = OdIfc4x4::kIfcActuatorTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration identifies the logical location of the address. */ enum IfcAddressTypeEnum { /** A postal distribution point address.*/ kIfcAddressTypeEnum_DISTRIBUTIONPOINT, /** A home address.*/ kIfcAddressTypeEnum_HOME, /** An office address.*/ kIfcAddressTypeEnum_OFFICE, /** A site address.*/ kIfcAddressTypeEnum_SITE, /** A user defined address type to be provided.*/ kIfcAddressTypeEnum_USERDEFINED, /** The value is unset.*/ kIfcAddressTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcAddressTypeEnum& getUnset() { static OdIfc4x4::IfcAddressTypeEnum nullEnum = OdIfc4x4::kIfcAddressTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcAirTerminalBoxTypeEnum& getUnset() { static OdIfc4x4::IfcAirTerminalBoxTypeEnum nullEnum = OdIfc4x4::kIfcAirTerminalBoxTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcAirTerminalTypeEnum& getUnset() { static OdIfc4x4::IfcAirTerminalTypeEnum nullEnum = OdIfc4x4::kIfcAirTerminalTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 passive energy recovery device with a heat pipe divided into evaporator and condenser sections.*/ kIfcAirToAirHeatRecoveryTypeEnum_HEATPIPE, /** 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, /** 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, /** 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, /** 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, /** 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 OdIfc4x4::IfcAirToAirHeatRecoveryTypeEnum& getUnset() { static OdIfc4x4::IfcAirToAirHeatRecoveryTypeEnum nullEnum = OdIfc4x4::kIfcAirToAirHeatRecoveryTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 electrical contact placed between the rails (in the four-foot way) to provide warnings in the locomotive cab.*/ kIfcAlarmTypeEnum_RAILWAYCROCODILE, /** A coin-sized device that is used as a loud warning signal to train drivers. It is usually placed on the top of the rail, usually secured with two lead straps, one on each side.*/ kIfcAlarmTypeEnum_RAILWAYDETONATOR, /** 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 OdIfc4x4::IfcAlarmTypeEnum& getUnset() { static OdIfc4x4::IfcAlarmTypeEnum nullEnum = OdIfc4x4::kIfcAlarmTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details The IfcAlignmentCantSegmentTypeEnum indicates the type of a segment of a cant alignment segment (IfcAlignmentCantSegment). */ enum IfcAlignmentCantSegmentTypeEnum { /** Non linear cant variation according to Bloss curve base formula.*/ kIfcAlignmentCantSegmentTypeEnum_BLOSSCURVE, /** For horizontal straight lines, compensation of lateral acceleration is not required and should be avoided. Therefore the applied cant value is constant 0.*/ kIfcAlignmentCantSegmentTypeEnum_CONSTANTCANT, /** Non linear cant variation according to Cosine curve base formula.*/ kIfcAlignmentCantSegmentTypeEnum_COSINECURVE, /** Non linear cant variation according to Helmert curve base formula.*/ kIfcAlignmentCantSegmentTypeEnum_HELMERTCURVE, /** Linear cant variation. This is the "natural" formula for horizontal clothoids.*/ kIfcAlignmentCantSegmentTypeEnum_LINEARTRANSITION, /** Non linear cant variation according to Sine curve base formula.*/ kIfcAlignmentCantSegmentTypeEnum_SINECURVE, /** Non linear cant variation according to Viennese bend base formula. The determining influence of the cant variation for the curve in the horizontal Cartesian 2D coordinate space is unique within all other transition curves.*/ kIfcAlignmentCantSegmentTypeEnum_VIENNESEBEND, /** The value is unset.*/ kIfcAlignmentCantSegmentTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcAlignmentCantSegmentTypeEnum& getUnset() { static OdIfc4x4::IfcAlignmentCantSegmentTypeEnum nullEnum = OdIfc4x4::kIfcAlignmentCantSegmentTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details The IfcAlignmentHorizontalSegmentTypeEnum indicates the type of a segment of a horizontal alignment segment (IfcAlignmentHorizontalSegment). Horizontal segments can be viewed from a geometric perspective and from a kinematic perspective. In recent times the kinematic perspective gained importance. The enumerations are detailed according to this development especially in modern track design. */ enum IfcAlignmentHorizontalSegmentTypeEnum { /** The Bloss transition is a more recent form of a high performance transition bend. Proposed in 1936. it is now in use in several railway networks. There is no established rough geometric approximation.*/ kIfcAlignmentHorizontalSegmentTypeEnum_BLOSSCURVE, /** In the geometric perspective, it denotes a connection between two points that follows a circular path. In the dynamic perspective, it denotes a segment with constant lateral acceleration on the moving vehicle, i.e. constant curvature.*/ kIfcAlignmentHorizontalSegmentTypeEnum_CIRCULARARC, /** In the geometric perspective, a clothoid denotes a connection between two points where the radius of curvature changes along the segment at a constant rate. The clothoid was an early achievement of geometry, also known as Euler's spiral or Cornu's spiral. It became very popular in road and rail design even before the widespread availability of computers because of the availability of tabulations of the normalized clothoid. Proper application of the so called clothoid constant provided fast solutions for all relevant parameters necessary to integrate clothoid segments between two consecutive segments with constant curvature. In most cases the clothoid smooths the curvature between a straight line and a circular arc. In the dynamic perspective, it denotes a segment with constant rate of lateral acceleration change induced by the curvature. The kinematic properties of the clothoid both reduce the exerted forces on the track by a train, improve the travel experience of train passengers and also reduce the stress of a car driver by avoiding sudden movements of the steering wheel. The kinematic advantages of the clothoid as a smoothing segment are true also for all the other transition bends currently in use.*/ kIfcAlignmentHorizontalSegmentTypeEnum_CLOTHOID, /** Cosine transition. The cosine transition was already discussed in 1868. Width the advent of high-speed rail it was applied in production designs. It is e.g. installed on Japanese high speed lines.*/ kIfcAlignmentHorizontalSegmentTypeEnum_COSINECURVE, /** In IFC CUBIC denotes a transition segment where x and y coordinates obey a cubic formula.*/ kIfcAlignmentHorizontalSegmentTypeEnum_CUBIC, /** The Helmert curve or Helmert transition is an early example of a high performance transition bend. It is now widely accepted in relevant science and engineering that the linear change of the clothoid induces unwanted kinematic influences to a running train at speeds higher than 125 km/h. In the geometry perspective the Helmert segment is the assembly of two parts of same length which mirror the same change in radius of curvature. A rough approximation is known as the biquadratic parabola.*/ kIfcAlignmentHorizontalSegmentTypeEnum_HELMERTCURVE, /** In the geometry perspective it denotes a straight connection between two points. In the dynamic perspective, it denotes a segment with a curvature with a value of 0. This means that no lateral acceleration acts on the moving vehicle.*/ kIfcAlignmentHorizontalSegmentTypeEnum_LINE, /** Sine transition or sinusoidal transition was suggested 1937. The curvature function is built up of one period of a sine function. The sine curve is characterised by particularly advantageous smoothing properties at the end points. Compared to the clothoid, it is twice as long.*/ kIfcAlignmentHorizontalSegmentTypeEnum_SINECURVE, /** The Viennese Bend (R) is an innovative track geometry transition element. Instead of analyzing the vehicle movement at the track plane the optimization efforts target a gravity center line at a defined height above the rails. As a consequence the path of the horizontal alignment center line is also influenced by the cant layout. The first part of the curvature formula is assembled from the basic function like the other transition bends. The additional term contains the bank angle "ψ" and the gravity center line height "h" and is unique to the Viennes Bend (R). This term causes a small movement contrary to the main direction in the x,y layout.*/ kIfcAlignmentHorizontalSegmentTypeEnum_VIENNESEBEND, /** The value is unset.*/ kIfcAlignmentHorizontalSegmentTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcAlignmentHorizontalSegmentTypeEnum& getUnset() { static OdIfc4x4::IfcAlignmentHorizontalSegmentTypeEnum nullEnum = OdIfc4x4::kIfcAlignmentHorizontalSegmentTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcAlignmentTypeEnum& getUnset() { static OdIfc4x4::IfcAlignmentTypeEnum nullEnum = OdIfc4x4::kIfcAlignmentTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details The IfcAlignmentVerticalSegmentTypeEnum indicates the type of a segment of a vertical alignment segment (IfcAlignmentVerticalSegment). */ enum IfcAlignmentVerticalSegmentTypeEnum { /** Vertical alignment segment where the derivative of vertical angle with respect to sloping length along the track (3D length) is constant.*/ kIfcAlignmentVerticalSegmentTypeEnum_CIRCULARARC, /** Vertical alignment segment where the derivative of vertical angle with respect to sloping length along the track (3D length) obeys a linear change.*/ kIfcAlignmentVerticalSegmentTypeEnum_CLOTHOID, /** Vertical alignment segment with constant gradient.*/ kIfcAlignmentVerticalSegmentTypeEnum_CONSTANTGRADIENT, /** Vertical alignment segment where the derivative of gradient with respect to distance along is constant.*/ kIfcAlignmentVerticalSegmentTypeEnum_PARABOLICARC, /** The value is unset.*/ kIfcAlignmentVerticalSegmentTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcAlignmentVerticalSegmentTypeEnum& getUnset() { static OdIfc4x4::IfcAlignmentVerticalSegmentTypeEnum nullEnum = OdIfc4x4::kIfcAlignmentVerticalSegmentTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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, /** Loading 3D*/ kIfcAnalysisModelTypeEnum_LOADING_3D, /** Out plane loading 2D*/ kIfcAnalysisModelTypeEnum_OUT_PLANE_LOADING_2D, /** User defined*/ kIfcAnalysisModelTypeEnum_USERDEFINED, /** Not defined*/ kIfcAnalysisModelTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcAnalysisModelTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcAnalysisModelTypeEnum& getUnset() { static OdIfc4x4::IfcAnalysisModelTypeEnum nullEnum = OdIfc4x4::kIfcAnalysisModelTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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, /** Full non-linear theory*/ kIfcAnalysisTheoryTypeEnum_FULL_NONLINEAR_THEORY, /** 2nd order theory*/ kIfcAnalysisTheoryTypeEnum_SECOND_ORDER_THEORY, /** 3rd order theory*/ kIfcAnalysisTheoryTypeEnum_THIRD_ORDER_THEORY, /** User defined.*/ kIfcAnalysisTheoryTypeEnum_USERDEFINED, /** Undefined.*/ kIfcAnalysisTheoryTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcAnalysisTheoryTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcAnalysisTheoryTypeEnum& getUnset() { static OdIfc4x4::IfcAnalysisTheoryTypeEnum nullEnum = OdIfc4x4::kIfcAnalysisTheoryTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration defines the different types of Annotation elements an IfcAnnotation object can represent. */ enum IfcAnnotationTypeEnum { /** Annotation used to illustrate lines connecting points of equal elevation or depth, on a map or chart.*/ kIfcAnnotationTypeEnum_CONTOURLINE, /** Annotation used to illustrate the measurement or size of an object, often accompanied by numerical values.*/ kIfcAnnotationTypeEnum_DIMENSION, /** Annotation used to illustrate lines connecting points of equal pressure on a map or chart.*/ kIfcAnnotationTypeEnum_ISOBAR, /** Annotation used to illustrate lines connecting points of equal illuminance or light intensity.*/ kIfcAnnotationTypeEnum_ISOLUX, /** Annotation used to illustrate lines connecting points of equal temperature on a map or chart.*/ kIfcAnnotationTypeEnum_ISOTHERM, /** Annotation that includes a line or arrow.*/ kIfcAnnotationTypeEnum_LEADER, /** Annotation used for survey information, such as survey points, survey lines or survey areas.*/ kIfcAnnotationTypeEnum_SURVEY, /** Annotation that employs graphical symbols or icons to represent specific meanings.*/ kIfcAnnotationTypeEnum_SYMBOL, /** A textual annotation.*/ kIfcAnnotationTypeEnum_TEXT, /** User-defined type*/ kIfcAnnotationTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcAnnotationTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcAnnotationTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcAnnotationTypeEnum& getUnset() { static OdIfc4x4::IfcAnnotationTypeEnum nullEnum = OdIfc4x4::kIfcAnnotationTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { enum IfcArchElementTypeEnum { kIfcArchElementTypeEnum_LINING, kIfcArchElementTypeEnum_SEGMENT, kIfcArchElementTypeEnum_STEELRIB, kIfcArchElementTypeEnum_USERDEFINED, kIfcArchElementTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcArchElementTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcArchElementTypeEnum& getUnset() { static OdIfc4x4::IfcArchElementTypeEnum nullEnum = OdIfc4x4::kIfcArchElementTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details IfcArithmeticOperatorEnum specifies the form of arithmetic operation implied by the relationship. */ enum IfcArithmeticOperatorEnum { /** Add*/ kIfcArithmeticOperatorEnum_ADD, /** Divide*/ kIfcArithmeticOperatorEnum_DIVIDE, /** Modulo. The remainder of division given two positive integer numbers.*/ kIfcArithmeticOperatorEnum_MODULO, /** Multiply*/ kIfcArithmeticOperatorEnum_MULTIPLY, /** Subtract*/ kIfcArithmeticOperatorEnum_SUBTRACT, /** The value is unset.*/ kIfcArithmeticOperatorEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcArithmeticOperatorEnum& getUnset() { static OdIfc4x4::IfcArithmeticOperatorEnum nullEnum = OdIfc4x4::kIfcArithmeticOperatorEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 in a factory.*/ kIfcAssemblyPlaceEnum_FACTORY, /** This assembly is assembled at site.*/ kIfcAssemblyPlaceEnum_SITE, /** No description available.*/ kIfcAssemblyPlaceEnum_NOTDEFINED, /** The value is unset.*/ kIfcAssemblyPlaceEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcAssemblyPlaceEnum& getUnset() { static OdIfc4x4::IfcAssemblyPlaceEnum nullEnum = OdIfc4x4::kIfcAssemblyPlaceEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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, kIfcAudioVisualApplianceTypeEnum_BEACON, /** 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, /** A communication terminal is an audio communication device that is usually installed along transportation infrastructure (railways, roads, tunnels etc.) in order to be used by the general public or operation agents for communication. It may specifically be used to make calls to emergency services in tunnels.*/ kIfcAudioVisualApplianceTypeEnum_COMMUNICATIONTERMINAL, /** 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 recording equipment is a device that records telephone calls or other types of audio data. It also provides the function of archiving and immediate replay.*/ kIfcAudioVisualApplianceTypeEnum_RECORDINGEQUIPMENT, kIfcAudioVisualApplianceTypeEnum_SIREN, /** 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 OdIfc4x4::IfcAudioVisualApplianceTypeEnum& getUnset() { static OdIfc4x4::IfcAudioVisualApplianceTypeEnum nullEnum = OdIfc4x4::kIfcAudioVisualApplianceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details The IfcBSplineCurveForm represents a part of a curve of some specific form. */ enum IfcBSplineCurveForm { /** 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 one branch of a hyperbola represented by a B-spline curve.*/ kIfcBSplineCurveForm_HYPERBOLIC_ARC, /** An arc of finite length of a parabola represented by a B-spline curve.*/ kIfcBSplineCurveForm_PARABOLIC_ARC, /** A connected sequence of line segments represented by degree 1 B-spline basis functions.*/ kIfcBSplineCurveForm_POLYLINE_FORM, /** 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 OdIfc4x4::IfcBSplineCurveForm& getUnset() { static OdIfc4x4::IfcBSplineCurveForm nullEnum = OdIfc4x4::kIfcBSplineCurveForm_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details The IfcBSplineSurfaceForm represents a part of a surface of some specific form. */ enum IfcBSplineSurfaceForm { /** A bounded portion of the surface of a right circular cone.*/ kIfcBSplineSurfaceForm_CONICAL_SURF, /** A bounded portion of a cylindrical surface.*/ kIfcBSplineSurfaceForm_CYLINDRICAL_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 a plane represented by a B-spline surface of degree 1 in each parameter.*/ kIfcBSplineSurfaceForm_PLANE_SURF, /** A bounded portion of one of the class of surfaces of degree 2 in the variables x, y and z.*/ kIfcBSplineSurfaceForm_QUADRIC_SURF, /** 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 bounded portion of a sphere, or a complete sphere, represented by a B-spline surface.*/ kIfcBSplineSurfaceForm_SPHERICAL_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 bounded portion of a surface of revolution.*/ kIfcBSplineSurfaceForm_SURF_OF_REVOLUTION, /** A torus, or portion of a torus, represented by a B-spline surface.*/ kIfcBSplineSurfaceForm_TOROIDAL_SURF, /** A surface for which no particular form is specified.*/ kIfcBSplineSurfaceForm_UNSPECIFIED, /** The value is unset.*/ kIfcBSplineSurfaceForm_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcBSplineSurfaceForm& getUnset() { static OdIfc4x4::IfcBSplineSurfaceForm nullEnum = OdIfc4x4::kIfcBSplineSurfaceForm_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 non-loadbearing beam on the longitudinal edge of bridge slab, usually encasing installations.*/ kIfcBeamTypeEnum_CORNICE, /** End portion of a girder transmitting loads to supports and providing moment resistance to adjoining segment.*/ kIfcBeamTypeEnum_DIAPHRAGM, /** A beam on the longitudinal edge of bridge slab, usually concrete, providing additional stiffening and protection from the elements.*/ kIfcBeamTypeEnum_EDGEBEAM, /** A segment of a girder (e.g. each span of a continuous girder).*/ kIfcBeamTypeEnum_GIRDER_SEGMENT, /** A beam on top of a retaining wall or a wing wall, preventing earth movement.*/ kIfcBeamTypeEnum_HATSTONE, /** A wide often prestressed beam with a hollow-core profile that usually serves as a slab component.*/ kIfcBeamTypeEnum_HOLLOWCORE, /** A beam used to support a floor or ceiling.*/ kIfcBeamTypeEnum_JOIST, /** A beam or horizontal piece of material over an opening (e.g. door, window).*/ kIfcBeamTypeEnum_LINTEL, /** A 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 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, /** 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 OdIfc4x4::IfcBeamTypeEnum& getUnset() { static OdIfc4x4::IfcBeamTypeEnum nullEnum = OdIfc4x4::kIfcBeamTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details Enumeration of Bearing Types. */ enum IfcBearingTypeEnum { /** The bearing functionality is provided by cylinder in a concave cylinder.*/ kIfcBearingTypeEnum_CYLINDRICAL, /** A disk bearing consist of an elastomeric disc between two metal plates.*/ kIfcBearingTypeEnum_DISK, /** 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 that ensures that the structure maintains the correct location or expansion/contraction path and takes no vertical load. Includes also restraint bearings.*/ kIfcBearingTypeEnum_GUIDE, /** 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, /** 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, /** The bearing functionality is provided by convex dome in a concave basin.*/ kIfcBearingTypeEnum_SPHERICAL, /** User-defined bearing element.*/ kIfcBearingTypeEnum_USERDEFINED, /** Undefined bearing element.*/ kIfcBearingTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcBearingTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcBearingTypeEnum& getUnset() { static OdIfc4x4::IfcBearingTypeEnum nullEnum = OdIfc4x4::kIfcBearingTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 equal to that set by the constraint.*/ kIfcBenchmarkEnum_EQUALTO, /** 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 (individual item) must be included in the aggregation (set, list or table) set by the constraint.*/ kIfcBenchmarkEnum_INCLUDEDIN, /** Identifies that an aggregation (set, list or table) must include the value (individual item) set by the constraint.*/ kIfcBenchmarkEnum_INCLUDES, /** 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 not equal to that set by the constraint.*/ kIfcBenchmarkEnum_NOTEQUALTO, /** Identifies that a value (individual item) must not be included in the aggregation (set, list or table) set by the constraint.*/ kIfcBenchmarkEnum_NOTINCLUDEDIN, /** Identifies that an aggregation (set, list or table) must not include the value (individual item) set by the constraint.*/ kIfcBenchmarkEnum_NOTINCLUDES, /** The value is unset.*/ kIfcBenchmarkEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcBenchmarkEnum& getUnset() { static OdIfc4x4::IfcBenchmarkEnum nullEnum = OdIfc4x4::kIfcBenchmarkEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details Enumeration defining the typical types of boilers. */ enum IfcBoilerTypeEnum { /** Steam boiler.*/ kIfcBoilerTypeEnum_STEAM, /** Water boiler.*/ kIfcBoilerTypeEnum_WATER, /** User-defined Boiler type.*/ kIfcBoilerTypeEnum_USERDEFINED, /** Undefined Boiler type.*/ kIfcBoilerTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcBoilerTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcBoilerTypeEnum& getUnset() { static OdIfc4x4::IfcBoilerTypeEnum nullEnum = OdIfc4x4::kIfcBoilerTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details Boolean operators that apply to the first and second Boolean operands. */ enum IfcBooleanOperator { /** The regularized set theoretic difference between the volumes defined by two solids.*/ kIfcBooleanOperator_DIFFERENCE, /** The operation of constructing the regularized set theoretic intersection of the volumes defined by two solids.*/ kIfcBooleanOperator_INTERSECTION, /** The operation of constructing the regularized set theoretic union of the volumes defined by two solids.*/ kIfcBooleanOperator_UNION, /** The value is unset.*/ kIfcBooleanOperator_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcBooleanOperator& getUnset() { static OdIfc4x4::IfcBooleanOperator nullEnum = OdIfc4x4::kIfcBooleanOperator_unset; return nullEnum; } } } namespace OdIfc4x4 { enum IfcBoreholeTypeEnum { kIfcBoreholeTypeEnum_COREDRILLING, kIfcBoreholeTypeEnum_DESTRUCTIVEDRILLING, kIfcBoreholeTypeEnum_DEWATERING, kIfcBoreholeTypeEnum_TRIALPIT, kIfcBoreholeTypeEnum_USERDEFINED, kIfcBoreholeTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcBoreholeTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcBoreholeTypeEnum& getUnset() { static OdIfc4x4::IfcBoreholeTypeEnum nullEnum = OdIfc4x4::kIfcBoreholeTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcBridgePartTypeEnum& getUnset() { static OdIfc4x4::IfcBridgePartTypeEnum nullEnum = OdIfc4x4::kIfcBridgePartTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcBridgeTypeEnum& getUnset() { static OdIfc4x4::IfcBridgeTypeEnum nullEnum = OdIfc4x4::kIfcBridgeTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration defines the different types of building element parts. */ enum IfcBuildingElementPartTypeEnum { /** 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, /** A large quarry stone or concrete shaped unit used as erosion prevention on slopes such as revetments and breakwaters. These units are grouped together into a Course layer.*/ kIfcBuildingElementPartTypeEnum_ARMOURUNIT, /** 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, /** Safety cages are an assembly of circular and vertical bars that are fastened to the stiles of fixed ladders and are arranged to enclose the path of a worker when climbing the ladder. Ladders so enclosed are also known as caged or hooped ladders.*/ kIfcBuildingElementPartTypeEnum_SAFETYCAGE, /** User-defined accessory.*/ kIfcBuildingElementPartTypeEnum_USERDEFINED, /** Undefined accessory.*/ kIfcBuildingElementPartTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcBuildingElementPartTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcBuildingElementPartTypeEnum& getUnset() { static OdIfc4x4::IfcBuildingElementPartTypeEnum nullEnum = OdIfc4x4::kIfcBuildingElementPartTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 space (e.g. the space allocated as a provision for mechanical equipment or furniture).*/ kIfcBuildingElementProxyTypeEnum_PROVISIONFORSPACE, /** The proxy denotes a provision for voids (a proposed opening not applied as void yet).*/ kIfcBuildingElementProxyTypeEnum_PROVISIONFORVOID, /** 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 OdIfc4x4::IfcBuildingElementProxyTypeEnum& getUnset() { static OdIfc4x4::IfcBuildingElementProxyTypeEnum nullEnum = OdIfc4x4::kIfcBuildingElementProxyTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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, /** No description available.*/ kIfcBuildingSystemTypeEnum_USERDEFINED, /** No description available.*/ kIfcBuildingSystemTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcBuildingSystemTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcBuildingSystemTypeEnum& getUnset() { static OdIfc4x4::IfcBuildingSystemTypeEnum nullEnum = OdIfc4x4::kIfcBuildingSystemTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration identifies different types of built systems. */ enum IfcBuiltSystemTypeEnum { /** A grouping of elements into a built system for preventing unwanted relocation of material particles in earthworks slopes or rock faces. Typical types of erosion prevention include:*/ kIfcBuiltSystemTypeEnum_EROSIONPREVENTION, /** System of doors, windows, and other fillings in openings in a built envelope that are designed to permit the passage of air or light.*/ kIfcBuiltSystemTypeEnum_FENESTRATION, kIfcBuiltSystemTypeEnum_FIREPROTECTION, /** System of shallow and deep foundation elements that transmit forces to the supporting ground.*/ kIfcBuiltSystemTypeEnum_FOUNDATION, /** System of built elements that transmit forces and stiffen the construction.*/ kIfcBuiltSystemTypeEnum_LOADBEARING, /** System of components and elements responsible for keeping or holding an element (a vessel, platform or set of catenary lines) in a desired position.*/ kIfcBuiltSystemTypeEnum_MOORING, /** System of built elements that provide the outer skin to protect the construction (such as the facade).*/ kIfcBuiltSystemTypeEnum_OUTERSHELL, /** 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.*/ kIfcBuiltSystemTypeEnum_PRESTRESSING, /** A set of functional tracks with explicit terminals. It is usually composed of a set of tracks with continuous track parts and alignments.*/ kIfcBuiltSystemTypeEnum_RAILWAYLINE, /** Railway track system. It is usually composed of continuous sequences of track parts and alignments.*/ kIfcBuiltSystemTypeEnum_RAILWAYTRACK, /** System of elements providing reinforcing to the structure.*/ kIfcBuiltSystemTypeEnum_REINFORCING, /** System of shading elements (external or internal) that permits the limitation or control of impact of natural sun light.*/ kIfcBuiltSystemTypeEnum_SHADING, /** A track circuit is an electric circuit of which the rails of a track section form a part, with usually a source of current connected at one end and a detection device at the other end for detecting whether this track section is clear or occupied by a vehicle. In a continuous signalling system, the track circuit can be used to transmit information between the ground and the train.*/ kIfcBuiltSystemTypeEnum_TRACKCIRCUIT, /** System of all transport elements in a facility that enable the transport of people or goods.*/ kIfcBuiltSystemTypeEnum_TRANSPORT, kIfcBuiltSystemTypeEnum_TUNNEL_LINING, kIfcBuiltSystemTypeEnum_TUNNEL_PRESUPPORT, kIfcBuiltSystemTypeEnum_TUNNEL_SUPPORT, kIfcBuiltSystemTypeEnum_WATERPROOFING, /** User-defined type*/ kIfcBuiltSystemTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcBuiltSystemTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcBuiltSystemTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcBuiltSystemTypeEnum& getUnset() { static OdIfc4x4::IfcBuiltSystemTypeEnum nullEnum = OdIfc4x4::kIfcBuiltSystemTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcBurnerTypeEnum& getUnset() { static OdIfc4x4::IfcBurnerTypeEnum nullEnum = OdIfc4x4::kIfcBurnerTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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, /** Connector fitting, typically used to join two ports together within a flow distribution system (e.g., a coupling used to join two duct segments).*/ kIfcCableCarrierFittingTypeEnum_CONNECTOR, /** A fitting at which two branches are taken from the main route of the cable carrier simultaneously.*/ kIfcCableCarrierFittingTypeEnum_CROSS, /** 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.).*/ kIfcCableCarrierFittingTypeEnum_JUNCTION, /** 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, /** A fitting with typically two ports having different shapes or sizes. Can also be used to change the direction of flow between connected elements.*/ kIfcCableCarrierFittingTypeEnum_TRANSITION, /** User-defined type.*/ kIfcCableCarrierFittingTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcCableCarrierFittingTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcCableCarrierFittingTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcCableCarrierFittingTypeEnum& getUnset() { static OdIfc4x4::IfcCableCarrierFittingTypeEnum nullEnum = OdIfc4x4::kIfcCableCarrierFittingTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details The IfcCableCarrierSegmentTypeEnum defines the range of different types of cable carrier segment that can be specified. */ enum IfcCableCarrierSegmentTypeEnum { /** A cable bracket is a horizontal cable support fixed at one end only, spaced at intervals, on which cables rest.*/ kIfcCableCarrierSegmentTypeEnum_CABLEBRACKET, /** 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, /** A catenary wire is a longitudinal wire supporting the grooved contact wires either directly or indirectly.*/ kIfcCableCarrierSegmentTypeEnum_CATENARYWIRE, /** An enclosed tubular carrier segment through which cables are pulled.*/ kIfcCableCarrierSegmentTypeEnum_CONDUITSEGMENT, /** A dropper is a cable carrier used to suspend cable from another cable. It could also conduct electricity.*/ kIfcCableCarrierSegmentTypeEnum_DROPPER, /** User-defined type.*/ kIfcCableCarrierSegmentTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcCableCarrierSegmentTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcCableCarrierSegmentTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcCableCarrierSegmentTypeEnum& getUnset() { static OdIfc4x4::IfcCableCarrierSegmentTypeEnum nullEnum = OdIfc4x4::kIfcCableCarrierSegmentTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 fan out is a special cable fitting that provides a safe transition from multi-fiber cable units to individual fibers.*/ kIfcCableFittingTypeEnum_FANOUT, /** 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 OdIfc4x4::IfcCableFittingTypeEnum& getUnset() { static OdIfc4x4::IfcCableFittingTypeEnum nullEnum = OdIfc4x4::kIfcCableFittingTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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, /** An electric conductor of an overhead contact line with which the current collectors make contact.*/ kIfcCableSegmentTypeEnum_CONTACTWIRESEGMENT, /** 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, /** A fiber segment is an individual optical fiber used in telecommunication systems to transmit data by means of optical signals.*/ kIfcCableSegmentTypeEnum_FIBERSEGMENT, /** A fiber tube is semi-rigid hollow plastic tube with a very small radius that houses and protects a certain number of optical fiber segments. An optical cable segment may contain many fiber tubes.*/ kIfcCableSegmentTypeEnum_FIBERTUBE, /** An optical cable segment is a cable segment that contains a variable number of optical fiber segments.*/ kIfcCableSegmentTypeEnum_OPTICALCABLESEGMENT, /** A stitch wire consists of auxiliary wires and different components (clamp) used in stitched suspension.*/ kIfcCableSegmentTypeEnum_STITCHWIRE, /** A pair of conductors contained in a copper cable. The pair is always used together to form a circuit to transmit data by means of electric signals.*/ kIfcCableSegmentTypeEnum_WIREPAIRSEGMENT, /** User-defined type.*/ kIfcCableSegmentTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcCableSegmentTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcCableSegmentTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcCableSegmentTypeEnum& getUnset() { static OdIfc4x4::IfcCableSegmentTypeEnum nullEnum = OdIfc4x4::kIfcCableSegmentTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details Enumeration of Caisson Foundation Types. */ enum IfcCaissonFoundationTypeEnum { /** Closed box.*/ kIfcCaissonFoundationTypeEnum_CAISSON, /** Open box.*/ kIfcCaissonFoundationTypeEnum_WELL, /** 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 OdIfc4x4::IfcCaissonFoundationTypeEnum& getUnset() { static OdIfc4x4::IfcCaissonFoundationTypeEnum nullEnum = OdIfc4x4::kIfcCaissonFoundationTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 { /** 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, /** A modification to the object has been made by the user and application defined by the LastModifyingUser and LastModifyingApplication respectively.*/ kIfcChangeActionEnum_MODIFIED, /** Object has not been modified.*/ kIfcChangeActionEnum_NOCHANGE, /** 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 OdIfc4x4::IfcChangeActionEnum& getUnset() { static OdIfc4x4::IfcChangeActionEnum nullEnum = OdIfc4x4::kIfcChangeActionEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details Enumeration defining the typical types of Chillers classified by their method of heat rejection. */ enum IfcChillerTypeEnum { /** Air cooled chiller.*/ kIfcChillerTypeEnum_AIRCOOLED, /** Heat recovery chiller.*/ kIfcChillerTypeEnum_HEATRECOVERY, /** Water cooled chiller.*/ kIfcChillerTypeEnum_WATERCOOLED, /** User-defined chiller type.*/ kIfcChillerTypeEnum_USERDEFINED, /** Undefined chiller type.*/ kIfcChillerTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcChillerTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcChillerTypeEnum& getUnset() { static OdIfc4x4::IfcChillerTypeEnum nullEnum = OdIfc4x4::kIfcChillerTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcChimneyTypeEnum& getUnset() { static OdIfc4x4::IfcChimneyTypeEnum nullEnum = OdIfc4x4::kIfcChimneyTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcCoilTypeEnum& getUnset() { static OdIfc4x4::IfcCoilTypeEnum nullEnum = OdIfc4x4::kIfcCoilTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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, /** 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 element embedded within a wall that can be required to be load bearing but may also only be used for decorative purposes.*/ kIfcColumnTypeEnum_PILASTER, /** 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 OdIfc4x4::IfcColumnTypeEnum& getUnset() { static OdIfc4x4::IfcColumnTypeEnum nullEnum = OdIfc4x4::kIfcColumnTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 self-acting artificial device, the behaviour of which is governed either in a stepwise manner by given decision rules or continuously in time by defined relationships, while the output variables of which are created from its input and state variables.*/ kIfcCommunicationsApplianceTypeEnum_AUTOMATON, /** 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, /** An intelligent peripheral is a device that offers a variety of specialized resources according to the corresponding service logical program under the control of SCP. These resources contain the receiver of DTMF (Dual-Tone Multi-Frequency, signal generator, record notice, etc.). An intelligent peripheral provides dedicated resource functions in the intelligent network, allocates, controls and manages various dedicated resources, communicates with other entities in the network, and completes SRF resource functions as well as the maintenance, management and statistics functions of resources.*/ kIfcCommunicationsApplianceTypeEnum_INTELLIGENTPERIPHERAL, /** An IP network equipment is a device that provides IP data transmission channel for telecom subsystems or other subsystems e.g., routers, network switches or firewalls.*/ kIfcCommunicationsApplianceTypeEnum_IPNETWORKEQUIPMENT, /** The lineside electronic unit (LEU) is the interface between the balise and interlocking in railway. The LEU acquires the information from the interlocking, and sends the appropriate information to the balises in concordance with the lineside signalling (if available).*/ kIfcCommunicationsApplianceTypeEnum_LINESIDEELECTRONICUNIT, /** 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, /** An optical line terminal is a service provider endpoint of a passive or active optical network. It is the terminal equipment for connecting fiber optic trunks.*/ kIfcCommunicationsApplianceTypeEnum_OPTICALLINETERMINAL, /** An optical network unit is a kind of optical transmission network connection equipment which is installed at user side.*/ kIfcCommunicationsApplianceTypeEnum_OPTICALNETWORKUNIT, /** A machine that has the primary function of printing text and/or graphics onto paper or other media.*/ kIfcCommunicationsApplianceTypeEnum_PRINTER, /** A radio block center is a specialised computing device in railway with specification for generating Movement Authorities (MA) and transmitting it to trains. It gets information from signalling control and from the trains in its section.*/ kIfcCommunicationsApplianceTypeEnum_RADIOBLOCKCENTER, /** 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, /** A system sending command to control and monitor the switches and circuit breakers or systems directly or not connected (e.g. via wires) within the traction power system remotely.*/ kIfcCommunicationsApplianceTypeEnum_TELECOMMAND, /** A telephony exchange is a device that ensures the routing of telephone calls and communications.*/ kIfcCommunicationsApplianceTypeEnum_TELEPHONYEXCHANGE, /** A transition component is a minor active device that converts electric signals to optical signals at the sender, and converts optical signals to electric signals at the receiver.*/ kIfcCommunicationsApplianceTypeEnum_TRANSITIONCOMPONENT, /** A transponder is a communication, monitoring, or control device that, upon receiving a signal, emits a different signal in response. Transponders can be either passive or active (e.g., electronic beacon, balise).*/ kIfcCommunicationsApplianceTypeEnum_TRANSPONDER, /** A transport equipment is a network element responsible for providing functionality of transport, multiplexing, switching, management and supervision of transmission channels between different hosts. The data transport service uses three specific metrics: the bandwidth, the jitter, and the packet loss rate.*/ kIfcCommunicationsApplianceTypeEnum_TRANSPORTEQUIPMENT, /** User-defined type.*/ kIfcCommunicationsApplianceTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcCommunicationsApplianceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcCommunicationsApplianceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcCommunicationsApplianceTypeEnum& getUnset() { static OdIfc4x4::IfcCommunicationsApplianceTypeEnum nullEnum = OdIfc4x4::kIfcCommunicationsApplianceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcComplexPropertyTemplateTypeEnum& getUnset() { static OdIfc4x4::IfcComplexPropertyTemplateTypeEnum nullEnum = OdIfc4x4::kIfcComplexPropertyTemplateTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details Enumeration defining the typical types of compressors. */ enum IfcCompressorTypeEnum { /** Positive-displacement reciprocating compressor where pressure is increased by a booster.*/ kIfcCompressorTypeEnum_BOOSTER, /** 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 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 shaft extends through a seal in the crankcase for an external drive.*/ kIfcCompressorTypeEnum_OPENTYPE, /** Positive-displacement compressor using a piston driven by a connecting rod from a crankshaft.*/ kIfcCompressorTypeEnum_RECIPROCATING, /** 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 compressor using a roller or rotor device.*/ kIfcCompressorTypeEnum_ROTARY, /** 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 compressor using two inter-fitting, spiral-shaped scroll members.*/ kIfcCompressorTypeEnum_SCROLL, /** Positive-displacement reciprocating compressor where the hermetic compressors use bolted construction amenable to field repair.*/ kIfcCompressorTypeEnum_SEMIHERMETIC, /** Positive-displacement rotary compressor using a single cylindrical main rotor that works with a pair of gate rotors.*/ kIfcCompressorTypeEnum_SINGLESCREW, /** Positive-displacement reciprocating compressor where vapor is compressed in a single stage.*/ kIfcCompressorTypeEnum_SINGLESTAGE, /** 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 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, /** Positive-displacement reciprocating compressor where the motor compressor is mounted inside a steel shell, which, in turn is sealed by welding.*/ kIfcCompressorTypeEnum_WELDEDSHELLHERMETIC, /** User-defined compressor type.*/ kIfcCompressorTypeEnum_USERDEFINED, /** Undefined compressor type.*/ kIfcCompressorTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcCompressorTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcCompressorTypeEnum& getUnset() { static OdIfc4x4::IfcCompressorTypeEnum nullEnum = OdIfc4x4::kIfcCompressorTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcCondenserTypeEnum& getUnset() { static OdIfc4x4::IfcCondenserTypeEnum nullEnum = OdIfc4x4::kIfcCondenserTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration defines the different ways how path based elements (such as layered IfcWall elements) can connect. */ enum IfcConnectionTypeEnum { /** Connection at the end of the connected element.*/ kIfcConnectionTypeEnum_ATEND, /** Connection along the path of the connected element.*/ kIfcConnectionTypeEnum_ATPATH, /** Connection at the start of the connected element.*/ kIfcConnectionTypeEnum_ATSTART, /** No description available.*/ kIfcConnectionTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcConnectionTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcConnectionTypeEnum& getUnset() { static OdIfc4x4::IfcConnectionTypeEnum nullEnum = OdIfc4x4::kIfcConnectionTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details IfcConstraintEnum is an enumeration used to qualify a constraint. */ enum IfcConstraintEnum { /** Qualifies a constraint such that it is advised that it is followed within or at the values set.*/ kIfcConstraintEnum_ADVISORY, /** 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, /** 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 OdIfc4x4::IfcConstraintEnum& getUnset() { static OdIfc4x4::IfcConstraintEnum nullEnum = OdIfc4x4::kIfcConstraintEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcConstructionEquipmentResourceTypeEnum& getUnset() { static OdIfc4x4::IfcConstructionEquipmentResourceTypeEnum nullEnum = OdIfc4x4::kIfcConstructionEquipmentResourceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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, /** User-defined resource.*/ kIfcConstructionMaterialResourceTypeEnum_USERDEFINED, /** Undefined resource.*/ kIfcConstructionMaterialResourceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcConstructionMaterialResourceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcConstructionMaterialResourceTypeEnum& getUnset() { static OdIfc4x4::IfcConstructionMaterialResourceTypeEnum nullEnum = OdIfc4x4::kIfcConstructionMaterialResourceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcConstructionProductResourceTypeEnum& getUnset() { static OdIfc4x4::IfcConstructionProductResourceTypeEnum nullEnum = OdIfc4x4::kIfcConstructionProductResourceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 discrete value, can be one of three or more values.*/ kIfcControllerTypeEnum_MULTIPOSITION, /** 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 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 OdIfc4x4::IfcControllerTypeEnum& getUnset() { static OdIfc4x4::IfcControllerTypeEnum nullEnum = OdIfc4x4::kIfcControllerTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This container defines the different predefined types of conveyor segments that can further specify an IfcConveyorSegment or IfcConveyorSegmentType. */ enum IfcConveyorSegmentTypeEnum { /** An endless belt for carrying material without stretching.*/ kIfcConveyorSegmentTypeEnum_BELTCONVEYOR, /** A conveyor in the form of connected buckets or segments that move in a continuous loop*/ kIfcConveyorSegmentTypeEnum_BUCKETCONVEYOR, /** Gravity-operated conveyor where media descends through a trough or chute.*/ kIfcConveyorSegmentTypeEnum_CHUTECONVEYOR, /** composed of a longitudinal screw in a trough or pipe that rotates to force media through the segment*/ kIfcConveyorSegmentTypeEnum_SCREWCONVEYOR, /** User-defined type*/ kIfcConveyorSegmentTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcConveyorSegmentTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcConveyorSegmentTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcConveyorSegmentTypeEnum& getUnset() { static OdIfc4x4::IfcConveyorSegmentTypeEnum nullEnum = OdIfc4x4::kIfcConveyorSegmentTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcCooledBeamTypeEnum& getUnset() { static OdIfc4x4::IfcCooledBeamTypeEnum nullEnum = OdIfc4x4::kIfcCooledBeamTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details Enumeration defining the typical types of cooling towers. */ enum IfcCoolingTowerTypeEnum { /** 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, /** 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 naturally.*/ kIfcCoolingTowerTypeEnum_NATURALDRAFT, /** 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 OdIfc4x4::IfcCoolingTowerTypeEnum& getUnset() { static OdIfc4x4::IfcCoolingTowerTypeEnum nullEnum = OdIfc4x4::kIfcCoolingTowerTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcCostItemTypeEnum& getUnset() { static OdIfc4x4::IfcCostItemTypeEnum nullEnum = OdIfc4x4::kIfcCostItemTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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, /** A complete listing of all work items forming construction or installation works in which costs have been allocated to work items.*/ kIfcCostScheduleTypeEnum_PRICEDBILLOFQUANTITIES, /** 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, /** 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 not yet been allocated to work items.*/ kIfcCostScheduleTypeEnum_UNPRICEDBILLOFQUANTITIES, /** User-defined type.*/ kIfcCostScheduleTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcCostScheduleTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcCostScheduleTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcCostScheduleTypeEnum& getUnset() { static OdIfc4x4::IfcCostScheduleTypeEnum nullEnum = OdIfc4x4::kIfcCostScheduleTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This container defines the different predefined types of course elements that can further specify an IfcCourse or IfcCourseType. */ enum IfcCourseTypeEnum { /** An Aggregate layer whose primary function is to protect against erosion of the underlying material by water e.g. riprap.*/ kIfcCourseTypeEnum_ARMOUR, /** Layer composed of broken stones under the sleepers.*/ kIfcCourseTypeEnum_BALLASTBED, /** A core course is the bulk internal structure of aggregate structures.*/ kIfcCourseTypeEnum_CORE, /** An Intermediate layer whose primary function is to prevent the washing through of fine materials.*/ kIfcCourseTypeEnum_FILTER, /** A layer within a pavement structure that forms a paved area or road.*/ kIfcCourseTypeEnum_PAVEMENT, /** Layer with the primary task to provide protection against erosion and scour.*/ kIfcCourseTypeEnum_PROTECTION, /** User-defined type*/ kIfcCourseTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcCourseTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcCourseTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcCourseTypeEnum& getUnset() { static OdIfc4x4::IfcCourseTypeEnum nullEnum = OdIfc4x4::kIfcCourseTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 cladding.*/ kIfcCoveringTypeEnum_CLADDING, /** A protective capping or covering of a wall or a parapet.*/ kIfcCoveringTypeEnum_COPING, /** The covering is used to represent a flooring.*/ kIfcCoveringTypeEnum_FLOORING, /** 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 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 roof covering.*/ kIfcCoveringTypeEnum_ROOFING, /** 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 isolate a distribution element from a space in which it is contained.*/ kIfcCoveringTypeEnum_SLEEVING, /** A layer of material used for leveling or flattening a surface.*/ kIfcCoveringTypeEnum_TOPPING, /** The covering is used for wrapping particularly of distribution elements using tape.*/ kIfcCoveringTypeEnum_WRAPPING, /** User defined type of covering.*/ kIfcCoveringTypeEnum_USERDEFINED, /** Undefined type of covering.*/ kIfcCoveringTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcCoveringTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcCoveringTypeEnum& getUnset() { static OdIfc4x4::IfcCoveringTypeEnum nullEnum = OdIfc4x4::kIfcCoveringTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcCrewResourceTypeEnum& getUnset() { static OdIfc4x4::IfcCrewResourceTypeEnum nullEnum = OdIfc4x4::kIfcCrewResourceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcCurtainWallTypeEnum& getUnset() { static OdIfc4x4::IfcCurtainWallTypeEnum nullEnum = OdIfc4x4::kIfcCurtainWallTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcCurveInterpolationEnum& getUnset() { static OdIfc4x4::IfcCurveInterpolationEnum nullEnum = OdIfc4x4::kIfcCurveInterpolationEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcDamperTypeEnum& getUnset() { static OdIfc4x4::IfcDamperTypeEnum nullEnum = OdIfc4x4::kIfcDamperTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcDataOriginEnum& getUnset() { static OdIfc4x4::IfcDataOriginEnum nullEnum = OdIfc4x4::kIfcDataOriginEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details IfcDerivedUnitEnum is an enumeration type for allowed types of derived units. */ enum IfcDerivedUnitEnum { /** Acceleration unit*/ kIfcDerivedUnitEnum_ACCELERATIONUNIT, /** Angularvelocity unit*/ kIfcDerivedUnitEnum_ANGULARVELOCITYUNIT, /** Area density unit*/ kIfcDerivedUnitEnum_AREADENSITYUNIT, /** Compound plane angle unit*/ kIfcDerivedUnitEnum_COMPOUNDPLANEANGLEUNIT, /** Curvature unit*/ kIfcDerivedUnitEnum_CURVATUREUNIT, /** Dynamic viscosity unit*/ kIfcDerivedUnitEnum_DYNAMICVISCOSITYUNIT, /** Heat flux density unit*/ kIfcDerivedUnitEnum_HEATFLUXDENSITYUNIT, /** Heating value unit*/ kIfcDerivedUnitEnum_HEATINGVALUEUNIT, /** Integer count rate unit*/ kIfcDerivedUnitEnum_INTEGERCOUNTRATEUNIT, /** Ion concentration unit*/ kIfcDerivedUnitEnum_IONCONCENTRATIONUNIT, /** Isothermal moisture capacity unit*/ kIfcDerivedUnitEnum_ISOTHERMALMOISTURECAPACITYUNIT, /** Kenematic viscosity unit*/ kIfcDerivedUnitEnum_KINEMATICVISCOSITYUNIT, /** Linear force unit*/ kIfcDerivedUnitEnum_LINEARFORCEUNIT, /** Linear moment unit*/ kIfcDerivedUnitEnum_LINEARMOMENTUNIT, /** Linear stiffness unit*/ kIfcDerivedUnitEnum_LINEARSTIFFNESSUNIT, /** Linear velocity unit*/ kIfcDerivedUnitEnum_LINEARVELOCITYUNIT, /** Luminous intensity distribution unit*/ kIfcDerivedUnitEnum_LUMINOUSINTENSITYDISTRIBUTIONUNIT, /** Mass denisity unit*/ kIfcDerivedUnitEnum_MASSDENSITYUNIT, /** Mass flowrate unit*/ kIfcDerivedUnitEnum_MASSFLOWRATEUNIT, /** Mass per length unit*/ kIfcDerivedUnitEnum_MASSPERLENGTHUNIT, /** Modulus of elasticity unit*/ kIfcDerivedUnitEnum_MODULUSOFELASTICITYUNIT, /** Modulus of linear subgrade reaction unit*/ kIfcDerivedUnitEnum_MODULUSOFLINEARSUBGRADEREACTIONUNIT, /** Modulus of rotational subgrade reaction unit*/ kIfcDerivedUnitEnum_MODULUSOFROTATIONALSUBGRADEREACTIONUNIT, /** Modulus of subgrade reaction unit*/ kIfcDerivedUnitEnum_MODULUSOFSUBGRADEREACTIONUNIT, /** Moistere diffusivity unit*/ kIfcDerivedUnitEnum_MOISTUREDIFFUSIVITYUNIT, /** Molecular weight unit*/ kIfcDerivedUnitEnum_MOLECULARWEIGHTUNIT, /** Moment of inertia unit*/ kIfcDerivedUnitEnum_MOMENTOFINERTIAUNIT, /** PH Unit*/ kIfcDerivedUnitEnum_PHUNIT, /** planar force unit*/ kIfcDerivedUnitEnum_PLANARFORCEUNIT, /** Rotational frequency unit*/ kIfcDerivedUnitEnum_ROTATIONALFREQUENCYUNIT, /** Rotational mass unit*/ kIfcDerivedUnitEnum_ROTATIONALMASSUNIT, /** Rotational stuffness unit*/ kIfcDerivedUnitEnum_ROTATIONALSTIFFNESSUNIT, /** Section area integral unit*/ kIfcDerivedUnitEnum_SECTIONAREAINTEGRALUNIT, /** Section modulus unit*/ kIfcDerivedUnitEnum_SECTIONMODULUSUNIT, /** Shear modulus unit*/ kIfcDerivedUnitEnum_SHEARMODULUSUNIT, /** Sound power level unit*/ kIfcDerivedUnitEnum_SOUNDPOWERLEVELUNIT, /** Sound power unit*/ kIfcDerivedUnitEnum_SOUNDPOWERUNIT, /** Sound pressure level unit*/ kIfcDerivedUnitEnum_SOUNDPRESSURELEVELUNIT, /** Sound pressure unit*/ kIfcDerivedUnitEnum_SOUNDPRESSUREUNIT, /** Specific heat capacity unit*/ kIfcDerivedUnitEnum_SPECIFICHEATCAPACITYUNIT, /** Temperature gradient unit*/ kIfcDerivedUnitEnum_TEMPERATUREGRADIENTUNIT, /** Temperature of change unit*/ kIfcDerivedUnitEnum_TEMPERATURERATEOFCHANGEUNIT, /** Thermal admittance unit*/ kIfcDerivedUnitEnum_THERMALADMITTANCEUNIT, /** Thermal Conductance unit*/ kIfcDerivedUnitEnum_THERMALCONDUCTANCEUNIT, /** Thermal expansion coefficient unit*/ kIfcDerivedUnitEnum_THERMALEXPANSIONCOEFFICIENTUNIT, /** Thermal resistance unit*/ kIfcDerivedUnitEnum_THERMALRESISTANCEUNIT, /** Thermal transmittance unit*/ kIfcDerivedUnitEnum_THERMALTRANSMITTANCEUNIT, /** Torque unit*/ kIfcDerivedUnitEnum_TORQUEUNIT, /** Vapor permeability unit*/ kIfcDerivedUnitEnum_VAPORPERMEABILITYUNIT, /** Valumetric flowrate unit*/ kIfcDerivedUnitEnum_VOLUMETRICFLOWRATEUNIT, /** 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 OdIfc4x4::IfcDerivedUnitEnum& getUnset() { static OdIfc4x4::IfcDerivedUnitEnum nullEnum = OdIfc4x4::kIfcDerivedUnitEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details IfcDirectionSenseEnum is an enumeration denoting whether sense of direction is positive or negative along the given axis. */ enum IfcDirectionSenseEnum { /** Direction defined to be negative.*/ kIfcDirectionSenseEnum_NEGATIVE, /** Direction defined to be positive.*/ kIfcDirectionSenseEnum_POSITIVE, /** The value is unset.*/ kIfcDirectionSenseEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcDirectionSenseEnum& getUnset() { static OdIfc4x4::IfcDirectionSenseEnum nullEnum = OdIfc4x4::kIfcDirectionSenseEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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, /** A device that prevents a sitting down of birds at electrically critical points and thus birds are protected against electrical shocks and disturbances by short circuit are avoided.*/ kIfcDiscreteAccessoryTypeEnum_BIRDPROTECTION, /** 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 cable arranger is a flexible accessory or a part of a component placed around cables to arrange and minimize flexing of them at the point where it is placed.*/ kIfcDiscreteAccessoryTypeEnum_CABLEARRANGER, /** A track elastic cushion is a kind of layer set on grooved sides of a concrete base, which is used for mitigating the impact of longitudinal and lateral load on track structures. A track elastic cushion shall only appear in ballastless track structures.*/ kIfcDiscreteAccessoryTypeEnum_ELASTIC_CUSHION, /** Assembly connection element between construction elements to allow for thermic differential expansions.*/ kIfcDiscreteAccessoryTypeEnum_EXPANSION_JOINT_DEVICE, /** Sealant, gap filler rod, packing material or other used to close a gap.*/ kIfcDiscreteAccessoryTypeEnum_FILLER, /** Construction material used to manage the passage of water around objects.*/ kIfcDiscreteAccessoryTypeEnum_FLASHING, /** A device designed to support and insulate a conductive element.*/ kIfcDiscreteAccessoryTypeEnum_INSULATOR, /** A lock is a mechanical or electronic fastening device that is released either by a physical object (e.g., key, fingerprint, RFID card, security token etc.), by supplying secret information (e.g., number permutation, password), or by a combination thereof.*/ kIfcDiscreteAccessoryTypeEnum_LOCK, /** A component that minimizes pump effects of the substructure.*/ kIfcDiscreteAccessoryTypeEnum_PANEL_STRENGTHENING, /** Point machine mounting device.*/ kIfcDiscreteAccessoryTypeEnum_POINTMACHINEMOUNTINGDEVICE, /** Point machine locking device.*/ kIfcDiscreteAccessoryTypeEnum_POINT_MACHINE_LOCKING_DEVICE, /** A rail component that prevents rails from tipping and twisting.*/ kIfcDiscreteAccessoryTypeEnum_RAILBRACE, /** A non-metallic pad placed between rail and baseplate or rail and sleeper, bearer or slab.*/ kIfcDiscreteAccessoryTypeEnum_RAILPAD, /** A device that prevents wearing of the rails throughout the flange of wheel to reduce noise emissions. It is often located at inner side of the outer rail in a curve or near turnouts (depends on function wearing or noise reduction).*/ kIfcDiscreteAccessoryTypeEnum_RAIL_LUBRICATION, /** A rail mechanical equipment is a mechnical equipment installed at railside, like blocking device, speed regulator, bias loaded inspector, track scale or controllable retarder.*/ kIfcDiscreteAccessoryTypeEnum_RAIL_MECHANICAL_EQUIPMENT, /** A column shoe or a beam shoe (beam hanger) used to support or secure an element.*/ kIfcDiscreteAccessoryTypeEnum_SHOE, /** A component which supports and retains the stock rail and a flat surface upon which the foot of the switch rail slides.*/ kIfcDiscreteAccessoryTypeEnum_SLIDINGCHAIR, /** A component in the track for sound absorption and may also absorb vibrations. It is often used in combination with slab tracks.*/ kIfcDiscreteAccessoryTypeEnum_SOUNDABSORPTION, kIfcDiscreteAccessoryTypeEnum_STRUCTURAL_SEALING, /** An equipment used to maintain the tension of conductors or cables.*/ kIfcDiscreteAccessoryTypeEnum_TENSIONINGEQUIPMENT, kIfcDiscreteAccessoryTypeEnum_WATER_BARRIER, /** User-defined accessory.*/ kIfcDiscreteAccessoryTypeEnum_USERDEFINED, /** Undefined accessory.*/ kIfcDiscreteAccessoryTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcDiscreteAccessoryTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcDiscreteAccessoryTypeEnum& getUnset() { static OdIfc4x4::IfcDiscreteAccessoryTypeEnum nullEnum = OdIfc4x4::kIfcDiscreteAccessoryTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details [object Object] */ enum IfcDistributionBoardTypeEnum { /** A distribution point on the incoming electrical supply, typically in domestic premises, at which protective devices are located.*/ kIfcDistributionBoardTypeEnum_CONSUMERUNIT, /** A distribution point at which voice and data communication signals are managed between communication devices.*/ kIfcDistributionBoardTypeEnum_DISPATCHINGBOARD, /** A distribution point at which connections are made for distribution of electrical circuits usually through protective devices.*/ kIfcDistributionBoardTypeEnum_DISTRIBUTIONBOARD, /** A distribution frame is used to interconnect and manage wiring between active equipment and subscriber. It might be composed of multiple distribution boards and other components.*/ kIfcDistributionBoardTypeEnum_DISTRIBUTIONFRAME, /** A distribution point at which starting and control devices for major plant items are located.*/ kIfcDistributionBoardTypeEnum_MOTORCONTROLCENTRE, /** A distribution point at which switching devices are located.*/ kIfcDistributionBoardTypeEnum_SWITCHBOARD, /** User-defined type*/ kIfcDistributionBoardTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcDistributionBoardTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcDistributionBoardTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcDistributionBoardTypeEnum& getUnset() { static OdIfc4x4::IfcDistributionBoardTypeEnum nullEnum = OdIfc4x4::kIfcDistributionBoardTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcDistributionChamberElementTypeEnum& getUnset() { static OdIfc4x4::IfcDistributionChamberElementTypeEnum nullEnum = OdIfc4x4::kIfcDistributionChamberElementTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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, /** Wireless connection to communication appliances for distribution of data or communication.*/ kIfcDistributionPortTypeEnum_WIRELESS, /** User-defined port type.*/ kIfcDistributionPortTypeEnum_USERDEFINED, /** Undefined port type.*/ kIfcDistributionPortTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcDistributionPortTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcDistributionPortTypeEnum& getUnset() { static OdIfc4x4::IfcDistributionPortTypeEnum nullEnum = OdIfc4x4::kIfcDistributionPortTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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, /** A longitudinal distribution system that supports contact wires, including catenary wire droppers and stich wires.*/ kIfcDistributionSystemEnum_CATENARY_SYSTEM, /** 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, /** Represents all wired networks that provide a data transmission channel using optical fiber cables, copper cables or both. It aggregates many technologies that are based on the multiplexing method.*/ kIfcDistributionSystemEnum_FIXEDTRANSMISSIONNETWORK, /** 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, /** Mobile network insures wireless communication by providing a secure platform for voice and data communication between infrastructure operators, including drivers, dispatchers, shunting team members and station controllers.*/ kIfcDistributionSystemEnum_MOBILENETWORK, /** Sensor-based system for building and infastructure environmental monitoring and control.*/ kIfcDistributionSystemEnum_MONITORINGSYSTEM, /** Items consumed and discarded, commonly known as trash or garbage.*/ kIfcDistributionSystemEnum_MUNICIPALSOLIDWASTE, /** Oil distribution system.*/ kIfcDistributionSystemEnum_OIL, /** Operating supplies system.*/ kIfcDistributionSystemEnum_OPERATIONAL, /** A system that allows communications between operators (e.g. switchtender, traffic regulator, operational agents, etc.) in operational centers and on the infrastructure site (e.g. railway, tunnel or road).*/ kIfcDistributionSystemEnum_OPERATIONALTELEPHONYSYSTEM, /** An overhead contact line system above the upper limit of the train using an overhead contact line and a catenary system to supply current to traction units.*/ kIfcDistributionSystemEnum_OVERHEAD_CONTACTLINE_SYSTEM, /** 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 distribution system which forms the intended path for the traction return current and the current under fault conditions.*/ kIfcDistributionSystemEnum_RETURN_CIRCUIT, kIfcDistributionSystemEnum_SAFETY, /** 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 OdIfc4x4::IfcDistributionSystemEnum& getUnset() { static OdIfc4x4::IfcDistributionSystemEnum nullEnum = OdIfc4x4::kIfcDistributionSystemEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details IfcDocumentConfidentialityEnum enables selection of the level of confidentiality of document information from a list of choices. */ enum IfcDocumentConfidentialityEnum { /** Document is confidential and its contents should not be revealed without permission.*/ kIfcDocumentConfidentialityEnum_CONFIDENTIAL, /** Document is personal to the author.*/ kIfcDocumentConfidentialityEnum_PERSONAL, /** Document is publicly available.*/ kIfcDocumentConfidentialityEnum_PUBLIC, /** Document availability is restricted.*/ kIfcDocumentConfidentialityEnum_RESTRICTED, /** User defined.*/ kIfcDocumentConfidentialityEnum_USERDEFINED, /** Not defined.*/ kIfcDocumentConfidentialityEnum_NOTDEFINED, /** The value is unset.*/ kIfcDocumentConfidentialityEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcDocumentConfidentialityEnum& getUnset() { static OdIfc4x4::IfcDocumentConfidentialityEnum nullEnum = OdIfc4x4::kIfcDocumentConfidentialityEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 final.*/ kIfcDocumentStatusEnum_FINAL, /** Document is a final draft.*/ kIfcDocumentStatusEnum_FINALDRAFT, /** Document has undergone revision.*/ kIfcDocumentStatusEnum_REVISION, /** Not defined.*/ kIfcDocumentStatusEnum_NOTDEFINED, /** The value is unset.*/ kIfcDocumentStatusEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcDocumentStatusEnum& getUnset() { static OdIfc4x4::IfcDocumentStatusEnum nullEnum = OdIfc4x4::kIfcDocumentStatusEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration defines the basic ways how individual door panels operate. */ enum IfcDoorPanelOperationEnum { /** Double acting. */ kIfcDoorPanelOperationEnum_DOUBLE_ACTING, /** Fixed panel. */ kIfcDoorPanelOperationEnum_FIXEDPANEL, /** Folding. */ kIfcDoorPanelOperationEnum_FOLDING, /** Revolving. */ kIfcDoorPanelOperationEnum_REVOLVING, /** Rolling up. */ kIfcDoorPanelOperationEnum_ROLLINGUP, /** Sliding. */ kIfcDoorPanelOperationEnum_SLIDING, /** Swinging. */ kIfcDoorPanelOperationEnum_SWINGING, /** User-defined.*/ kIfcDoorPanelOperationEnum_USERDEFINED, /** Not defined.*/ kIfcDoorPanelOperationEnum_NOTDEFINED, /** The value is unset.*/ kIfcDoorPanelOperationEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcDoorPanelOperationEnum& getUnset() { static OdIfc4x4::IfcDoorPanelOperationEnum nullEnum = OdIfc4x4::kIfcDoorPanelOperationEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcDoorPanelPositionEnum& getUnset() { static OdIfc4x4::IfcDoorPanelPositionEnum nullEnum = OdIfc4x4::kIfcDoorPanelPositionEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration defines the different predefined types of an IfcDoor or IfcDoorType object. */ enum IfcDoorTypeEnum { /** A boom barrier (also known as a boom gate) is a bar, or pole pivoted to allow the boom to block vehicular or pedestrian access through a controlled point.*/ kIfcDoorTypeEnum_BOOM_BARRIER, /** 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, /** A mechanical gate consisting of revolving arms, allowing only one person at a time to pass through.*/ kIfcDoorTypeEnum_TURNSTILE, /** User-defined door element.*/ kIfcDoorTypeEnum_USERDEFINED, /** Undefined door element.*/ kIfcDoorTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcDoorTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcDoorTypeEnum& getUnset() { static OdIfc4x4::IfcDoorTypeEnum nullEnum = OdIfc4x4::kIfcDoorTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 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 two panels, one is folding to the left, the other is folding to the right.*/ kIfcDoorTypeOperationEnum_DOUBLE_DOOR_FOLDING, /** Double panel lifting vertical*/ kIfcDoorTypeOperationEnum_DOUBLE_DOOR_LIFTING_VERTICAL, /** 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 two panels, one is sliding to the left the other is sliding to the right.*/ kIfcDoorTypeOperationEnum_DOUBLE_DOOR_SLIDING, /** 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 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, /** Lifting horizontal*/ kIfcDoorTypeOperationEnum_LIFTING_HORIZONTAL, /** Lifting vertical left*/ kIfcDoorTypeOperationEnum_LIFTING_VERTICAL_LEFT, /** Lifting vertical right*/ kIfcDoorTypeOperationEnum_LIFTING_VERTICAL_RIGHT, /** 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, /** Revolving vertical*/ kIfcDoorTypeOperationEnum_REVOLVING_VERTICAL, /** Door that opens by rolling up.*/ kIfcDoorTypeOperationEnum_ROLLINGUP, /** 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 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 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 OdIfc4x4::IfcDoorTypeOperationEnum& getUnset() { static OdIfc4x4::IfcDoorTypeOperationEnum nullEnum = OdIfc4x4::kIfcDoorTypeOperationEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcDuctFittingTypeEnum& getUnset() { static OdIfc4x4::IfcDuctFittingTypeEnum nullEnum = OdIfc4x4::kIfcDuctFittingTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 flexible segment is a continuous non-linear segment of duct that can be deformed and change the direction of flow.*/ kIfcDuctSegmentTypeEnum_FLEXIBLESEGMENT, /** A rigid segment is a continuous linear segment of duct that cannot be deformed.*/ kIfcDuctSegmentTypeEnum_RIGIDSEGMENT, /** User-defined segment.*/ kIfcDuctSegmentTypeEnum_USERDEFINED, /** Undefined segment.*/ kIfcDuctSegmentTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcDuctSegmentTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcDuctSegmentTypeEnum& getUnset() { static OdIfc4x4::IfcDuctSegmentTypeEnum nullEnum = OdIfc4x4::kIfcDuctSegmentTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcDuctSilencerTypeEnum& getUnset() { static OdIfc4x4::IfcDuctSilencerTypeEnum nullEnum = OdIfc4x4::kIfcDuctSilencerTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { enum IfcEarthingElementTypeEnum { kIfcEarthingElementTypeEnum_EARTHINGSTRIP, kIfcEarthingElementTypeEnum_FIXEDTERMINAL, kIfcEarthingElementTypeEnum_GROUNDINGMESH, kIfcEarthingElementTypeEnum_GROUNDINGPLATE, kIfcEarthingElementTypeEnum_GROUNDINGROD, kIfcEarthingElementTypeEnum_USERDEFINED, kIfcEarthingElementTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcEarthingElementTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcEarthingElementTypeEnum& getUnset() { static OdIfc4x4::IfcEarthingElementTypeEnum nullEnum = OdIfc4x4::kIfcEarthingElementTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This container defines the different predefined types of earthworks cut elements that can specify an IfcEarthworksCut. */ enum IfcEarthworksCutTypeEnum { kIfcEarthworksCutTypeEnum_ANCHOREDOPENEXCAVATION, /** Excavation for basements of buildings, abutments of bridges or similar structures either partially or completely below ground level.*/ kIfcEarthworksCutTypeEnum_BASE_EXCAVATION, kIfcEarthworksCutTypeEnum_BRACEDOPENEXCAVATION, kIfcEarthworksCutTypeEnum_CONFINEDOPENEXCAVATION, /** Excavation where soil or rock below topsoil is cut to the depth required for the construction of facilities such as roads and railways. The removed material can be used as fill (IfcEarthworksElement) for embankments or to form a level surface on which to build.*/ kIfcEarthworksCutTypeEnum_CUT, /** Underwater excavation to recover material or to create a greater depth of water.*/ kIfcEarthworksCutTypeEnum_DREDGING, /** General type of excavation when more accurate type is not specified.*/ kIfcEarthworksCutTypeEnum_EXCAVATION, /** Excavation that goes beyond the depth required for construction, in order to replace unsuitable material.*/ kIfcEarthworksCutTypeEnum_OVEREXCAVATION, /** Removal of expired material from top of pavement to be replaced by new material.*/ kIfcEarthworksCutTypeEnum_PAVEMENTMILLING, /** Removal of the soft part of the existing road slope, where it is dug into steps, when widening a road.*/ kIfcEarthworksCutTypeEnum_STEPEXCAVATION, /** Excavation where the topmost layer of soil containing organic material is cut or stripped. The removed topsoil can be used as fill (EarthworksElement) e.g. where planting is planned.*/ kIfcEarthworksCutTypeEnum_TOPSOILREMOVAL, /** Excavation whose length greatly exceeds the depth and width. Trench is typically excavated for strip foundations or for buried services such as drainage or cabling.*/ kIfcEarthworksCutTypeEnum_TRENCH, /** User-defined type*/ kIfcEarthworksCutTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcEarthworksCutTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcEarthworksCutTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcEarthworksCutTypeEnum& getUnset() { static OdIfc4x4::IfcEarthworksCutTypeEnum nullEnum = OdIfc4x4::kIfcEarthworksCutTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This container defines the different predefined types of earthworks fill elements that can specify an IfcEarthworksFill. */ enum IfcEarthworksFillTypeEnum { /** Fill behind retaining walls or other structures such as quays, behind abutments and bridges.*/ kIfcEarthworksFillTypeEnum_BACKFILL, /** Embankment built on the side of the main road structure to reduce the settlement of the road.*/ kIfcEarthworksFillTypeEnum_COUNTERWEIGHT, /** Predominantly longitudinal type of earthworks element with no other particular assigned type according to its role in Pavement or Subgrade.*/ kIfcEarthworksFillTypeEnum_EMBANKMENT, /** Side slope (batter) fill abutting the road structure or back slope fill.*/ kIfcEarthworksFillTypeEnum_SLOPEFILL, /** Type of earthworks element forming the structure below pavement and above natural soil.*/ kIfcEarthworksFillTypeEnum_SUBGRADE, /** Upper part of the soil, natural or constructed, that supports the loads transmitted by the overlying structure of a road, runway, or similar hard surface.*/ kIfcEarthworksFillTypeEnum_SUBGRADEBED, /** Section of subgrade to ensure the consistency of stiffness and prevent uneven settlement. Transition section may appear e.g. between: embankment and bridge abutment; embankment and transverse structure; cutting and tunnel; embankment and cutting.*/ kIfcEarthworksFillTypeEnum_TRANSITIONSECTION, /** User-defined type*/ kIfcEarthworksFillTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcEarthworksFillTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcEarthworksFillTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcEarthworksFillTypeEnum& getUnset() { static OdIfc4x4::IfcEarthworksFillTypeEnum nullEnum = OdIfc4x4::kIfcEarthworksFillTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 cooling water. A freestanding water cooler is a 'plugged' appliance whose load may be removed from an electric circuit.*/ kIfcElectricApplianceTypeEnum_FREESTANDINGWATERCOOLER, /** 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, /** 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 OdIfc4x4::IfcElectricApplianceTypeEnum& getUnset() { static OdIfc4x4::IfcElectricApplianceTypeEnum nullEnum = OdIfc4x4::kIfcElectricApplianceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcElectricDistributionBoardTypeEnum& getUnset() { static OdIfc4x4::IfcElectricDistributionBoardTypeEnum nullEnum = OdIfc4x4::kIfcElectricDistributionBoardTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 electric charge when an external power supply is present using the electrical property of capacitance. Two-terminal device characterized essentially by its capacitance.*/ kIfcElectricFlowStorageDeviceTypeEnum_CAPACITOR, /** A device that stores electrical energy when an external power supply is present using the electrical property of capacitance.*/ kIfcElectricFlowStorageDeviceTypeEnum_CAPACITORBANK, /** A device that is used to fix or adjust the parameter of electric energy, such as voltage loss, power factor and so on.*/ kIfcElectricFlowStorageDeviceTypeEnum_COMPENSATOR, /** A device that constantly injects currents that precisely correspond to the harmonic components drawn by the load.*/ kIfcElectricFlowStorageDeviceTypeEnum_HARMONICFILTER, /** A device used in circuits or power systems due to their inductance, acting as a component of electric storage device.*/ kIfcElectricFlowStorageDeviceTypeEnum_INDUCTOR, /** A device that stores electrical energy in a magnetic field using electrical property of inductance.*/ kIfcElectricFlowStorageDeviceTypeEnum_INDUCTORBANK, /** A recharger or battery charger is a device used to put energy into a secondary cell or rechargeable battery by forcing an electric current through it.*/ kIfcElectricFlowStorageDeviceTypeEnum_RECHARGER, /** 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 OdIfc4x4::IfcElectricFlowStorageDeviceTypeEnum& getUnset() { static OdIfc4x4::IfcElectricFlowStorageDeviceTypeEnum nullEnum = OdIfc4x4::kIfcElectricFlowStorageDeviceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details The IfcElectricFlowTreatmentDeviceTypeEnum defines the range of different types of electric flow treatment device that can be specified. */ enum IfcElectricFlowTreatmentDeviceTypeEnum { /** Linear two-port device designed to transmit spectral components of the input quantity according to a specified law, generally in order to pass the components in certain frequency bands and to attenuate those in other bands.*/ kIfcElectricFlowTreatmentDeviceTypeEnum_ELECTRONICFILTER, /** User-defined type*/ kIfcElectricFlowTreatmentDeviceTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcElectricFlowTreatmentDeviceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcElectricFlowTreatmentDeviceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcElectricFlowTreatmentDeviceTypeEnum& getUnset() { static OdIfc4x4::IfcElectricFlowTreatmentDeviceTypeEnum nullEnum = OdIfc4x4::kIfcElectricFlowTreatmentDeviceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcElectricGeneratorTypeEnum& getUnset() { static OdIfc4x4::IfcElectricGeneratorTypeEnum nullEnum = OdIfc4x4::kIfcElectricGeneratorTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcElectricMotorTypeEnum& getUnset() { static OdIfc4x4::IfcElectricMotorTypeEnum nullEnum = OdIfc4x4::kIfcElectricMotorTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details The IfcElectricTimeControlTypeEnum defines different types of electrical time control devices. */ enum IfcElectricTimeControlTypeEnum { /** Electromagnetically operated contactor for making or breaking a control circuit.*/ kIfcElectricTimeControlTypeEnum_RELAY, /** 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, /** User-defined type.*/ kIfcElectricTimeControlTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcElectricTimeControlTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcElectricTimeControlTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcElectricTimeControlTypeEnum& getUnset() { static OdIfc4x4::IfcElectricTimeControlTypeEnum nullEnum = OdIfc4x4::kIfcElectricTimeControlTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration defines the basic configuration types for element assemblies. */ enum IfcElementAssemblyTypeEnum { /** A bridge abutment built up of walls, beams, slabs etc.*/ kIfcElementAssemblyTypeEnum_ABUTMENT, /** 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 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, /** Device which permits longitudinal relative rail movement of two adjacent rails, while maintaining correct guidance and support.*/ kIfcElementAssemblyTypeEnum_DILATATIONPANEL, kIfcElementAssemblyTypeEnum_DUCTBANK, /** An assembly forming the support structure of a chamber (lock, dock) gate and associated elements, plus the containment of operational equipment.*/ kIfcElementAssemblyTypeEnum_ENTRANCEWORKS, /** 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, /** A framework of spaced cables or bars that are parallel to or cross each other.*/ kIfcElementAssemblyTypeEnum_GRID, /** An assembly of plates, members, cables or fasteners that form a vertical structure for the support or mounting of other equipment such as lights, sonar or wireless transmitters.*/ kIfcElementAssemblyTypeEnum_MAST, /** An intermediate support e.g. in a bridge, built up of walls, columns, beams etc.*/ kIfcElementAssemblyTypeEnum_PIER, kIfcElementAssemblyTypeEnum_PRESUPPORTFACE, kIfcElementAssemblyTypeEnum_PRESUPPORTVAULT, /** A vertical structure supporting cables in suspended or stayed structure.*/ kIfcElementAssemblyTypeEnum_PYLON, /** A complex assembly made up of several components like blocking device, speed regulator, bias loaded inspector, track scale or controllable retarder.*/ kIfcElementAssemblyTypeEnum_RAIL_MECHANICAL_EQUIPMENT_ASSEMBLY, /** Assembled reinforcement elements.*/ kIfcElementAssemblyTypeEnum_REINFORCEMENT_UNIT, /** A structure built up of beams, columns, etc. with moment-resisting joints, such as gantry*/ kIfcElementAssemblyTypeEnum_RIGID_FRAME, kIfcElementAssemblyTypeEnum_RING, /** A structure, fairly quick to setup, move or dismantle, used to give protection, especially from the weather or intrusion.*/ kIfcElementAssemblyTypeEnum_SHELTER, /** An assembly to physically aggregate together one or more signal instances (and also sign instances) including any supporting structural elements such as a simple pole or a rigid frame gantry.*/ kIfcElementAssemblyTypeEnum_SIGNALASSEMBLY, /** Slabs, laid out in one plane.*/ kIfcElementAssemblyTypeEnum_SLAB_FIELD, /** An obstacle (with oil catchment basin) installed typically in a bus lane to prevent other traffic with lower ground clearance from using it. Also Sump breaker or Sump trap.*/ kIfcElementAssemblyTypeEnum_SUMPBUSTER, /** An assembly intends to support Overhead Contact Line System. It includes foundation, supporting elements and suspension assembly.*/ kIfcElementAssemblyTypeEnum_SUPPORTINGASSEMBLY, /** A complex assembly of components used to suspend elements or cable segments.*/ kIfcElementAssemblyTypeEnum_SUSPENSIONASSEMBLY, /** Trackwork ensuring the support and guidance of a vehicle along a route. It consists of assembly of rail, sleepers and fastenings.*/ kIfcElementAssemblyTypeEnum_TRACKPANEL, /** A common assembly used to insure the switching function. It is composed of switches, control instruments and other components.*/ kIfcElementAssemblyTypeEnum_TRACTION_SWITCHING_ASSEMBLY, /** A structure on the carriageway to control the speed of vehicles.*/ kIfcElementAssemblyTypeEnum_TRAFFIC_CALMING_DEVICE, /** A structure built up of members with (quasi) pinned joint.*/ kIfcElementAssemblyTypeEnum_TRUSS, /** Trackwork ensuring the support and guidance of a vehicle along any given route among various diverging or intersecting tracks.*/ kIfcElementAssemblyTypeEnum_TURNOUTPANEL, /** User-defined element assembly.*/ kIfcElementAssemblyTypeEnum_USERDEFINED, /** Undefined element assembly.*/ kIfcElementAssemblyTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcElementAssemblyTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcElementAssemblyTypeEnum& getUnset() { static OdIfc4x4::IfcElementAssemblyTypeEnum nullEnum = OdIfc4x4::kIfcElementAssemblyTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcElementCompositionEnum& getUnset() { static OdIfc4x4::IfcElementCompositionEnum nullEnum = OdIfc4x4::kIfcElementCompositionEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcEngineTypeEnum& getUnset() { static OdIfc4x4::IfcEngineTypeEnum nullEnum = OdIfc4x4::kIfcEngineTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details Enumeration defining the typical types of evaporative coolers. */ enum IfcEvaporativeCoolerTypeEnum { /** 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, /** 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 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, /** 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, /** 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 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, /** 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 OdIfc4x4::IfcEvaporativeCoolerTypeEnum& getUnset() { static OdIfc4x4::IfcEvaporativeCoolerTypeEnum nullEnum = OdIfc4x4::kIfcEvaporativeCoolerTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details Enumeration defining the typical types of evaporators. */ enum IfcEvaporatorTypeEnum { /** Direct-expansion evaporator.*/ kIfcEvaporatorTypeEnum_DIRECTEXPANSION, /** Direct-expansion evaporator where a refrigerant evaporates inside plates brazed or welded together to make up an assembly of separate channels.*/ kIfcEvaporatorTypeEnum_DIRECTEXPANSIONBRAZEDPLATE, /** 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, /** 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 OdIfc4x4::IfcEvaporatorTypeEnum& getUnset() { static OdIfc4x4::IfcEvaporatorTypeEnum nullEnum = OdIfc4x4::kIfcEvaporatorTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 complex combination of things.*/ kIfcEventTriggerTypeEnum_EVENTCOMPLEX, /** An event trigger that is a message or set of information.*/ kIfcEventTriggerTypeEnum_EVENTMESSAGE, /** An event trigger that is a rule or constraint.*/ kIfcEventTriggerTypeEnum_EVENTRULE, /** An event trigger that is at, or occurs after, a particular point in or period of time.*/ kIfcEventTriggerTypeEnum_EVENTTIME, /** User defined.*/ kIfcEventTriggerTypeEnum_USERDEFINED, /** Not defined.*/ kIfcEventTriggerTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcEventTriggerTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcEventTriggerTypeEnum& getUnset() { static OdIfc4x4::IfcEventTriggerTypeEnum nullEnum = OdIfc4x4::kIfcEventTriggerTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details The IfcEventTypeEnum defines the range of different types of event that can be specified. */ enum IfcEventTypeEnum { /** A terminating event of a process.*/ kIfcEventTypeEnum_ENDEVENT, /** An event that occurs at an intermediate stage of a process.*/ kIfcEventTypeEnum_INTERMEDIATEEVENT, /** An initiating event of a process.*/ kIfcEventTypeEnum_STARTEVENT, /** User defined.*/ kIfcEventTypeEnum_USERDEFINED, /** Not defined.*/ kIfcEventTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcEventTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcEventTypeEnum& getUnset() { static OdIfc4x4::IfcEventTypeEnum nullEnum = OdIfc4x4::kIfcEventTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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, /** Space occupied by a neighboring building.*/ kIfcExternalSpatialElementTypeEnum_EXTERNAL_FIRE, /** External volume covered with water around the building.*/ kIfcExternalSpatialElementTypeEnum_EXTERNAL_WATER, /** No description available.*/ kIfcExternalSpatialElementTypeEnum_USERDEFINED, /** No description available.*/ kIfcExternalSpatialElementTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcExternalSpatialElementTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcExternalSpatialElementTypeEnum& getUnset() { static OdIfc4x4::IfcExternalSpatialElementTypeEnum nullEnum = OdIfc4x4::kIfcExternalSpatialElementTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { enum IfcFaceExcavationTypeEnum { kIfcFaceExcavationTypeEnum_CROSSCONNECTION, kIfcFaceExcavationTypeEnum_FULLFACE, kIfcFaceExcavationTypeEnum_PILOTBORE, kIfcFaceExcavationTypeEnum_REAMING, kIfcFaceExcavationTypeEnum_SHAFT, kIfcFaceExcavationTypeEnum_STAGED, kIfcFaceExcavationTypeEnum_USERDEFINED, kIfcFaceExcavationTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcFaceExcavationTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcFaceExcavationTypeEnum& getUnset() { static OdIfc4x4::IfcFaceExcavationTypeEnum nullEnum = OdIfc4x4::kIfcFaceExcavationTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This container defines the different common predefined types of facility parts that can further specify an IfcFacilityPartCommon. */ enum IfcFacilityPartCommonTypeEnum { /** A vertical facility part for elements belonging to the space above the finished ground.*/ kIfcFacilityPartCommonTypeEnum_ABOVEGROUND, /** A vertical facility part for the containment of elements below the finished ground. This may include for example earthworks elements and elements in a pavement structure.*/ kIfcFacilityPartCommonTypeEnum_BELOWGROUND, /** A longitudinal facility part providing an at grade junction between two or more segments of longitudinal facilities usually of the same type.*/ kIfcFacilityPartCommonTypeEnum_JUNCTION, /** A longitudinal facility part providing an at grade crossing between two or more different modes of transport e.g. road and railway or road and pedestrian.*/ kIfcFacilityPartCommonTypeEnum_LEVELCROSSING, /** A longitudinal facility part encompassing a linear portion of the facility defined by some uniform characteristics, or a transition between segments of uniform characteristics.*/ kIfcFacilityPartCommonTypeEnum_SEGMENT, /** A vertical facility part comprising of an underlying or supporting structure. this can be above or below finished ground level.*/ kIfcFacilityPartCommonTypeEnum_SUBSTRUCTURE, /** A vertical facility part comprising of the upper volume of a structure, usually forming the volume of operation or the receiving of live loading.*/ kIfcFacilityPartCommonTypeEnum_SUPERSTRUCTURE, /** A longitudinal facility part that represents a termination segment of a longitudinal facility such as the end of a breakwater, road or rail section.*/ kIfcFacilityPartCommonTypeEnum_TERMINAL, /** User-defined type*/ kIfcFacilityPartCommonTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcFacilityPartCommonTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcFacilityPartCommonTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcFacilityPartCommonTypeEnum& getUnset() { static OdIfc4x4::IfcFacilityPartCommonTypeEnum nullEnum = OdIfc4x4::kIfcFacilityPartCommonTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This container defines the different usage types of conveyor segments that can further specify an IfcFacilityPart. */ enum IfcFacilityUsageEnum { /** A Lateral usage implies a facility part is a lateral (left, right, centre etc.) subdivision of a longitudinal segment or facility. Common uses include traffic lanes, road or rail side embankments etc.*/ kIfcFacilityUsageEnum_LATERAL, /** A longitudinal usage implies a subdivision along a linear facility where the part has a defined start and end along the facility alignment(s).*/ kIfcFacilityUsageEnum_LONGITUDINAL, /** A regional usage implies a bounded subdivision in the "X-Y plane" of a parent IfcSpatialStructureElement. The parent IfcSpatialStructureElement can be longitudinal or regional in nature.*/ kIfcFacilityUsageEnum_REGION, /** A vertical usage implies a subdivision in the "Z plane" usually signifying a defined elevation level or controlled volume within a segment of the Z plane.*/ kIfcFacilityUsageEnum_VERTICAL, /** User-defined type.*/ kIfcFacilityUsageEnum_USERDEFINED, /** Undefined type.*/ kIfcFacilityUsageEnum_NOTDEFINED, /** The value is unset.*/ kIfcFacilityUsageEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcFacilityUsageEnum& getUnset() { static OdIfc4x4::IfcFacilityUsageEnum nullEnum = OdIfc4x4::kIfcFacilityUsageEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details Enumeration defining the typical types of fans. */ enum IfcFanTypeEnum { /** Air flows through the impeller radially using blades that are airfoil shaped.*/ kIfcFanTypeEnum_CENTRIFUGALAIRFOIL, /** Air flows through the impeller radially using blades that are backward curved.*/ kIfcFanTypeEnum_CENTRIFUGALBACKWARDINCLINEDCURVED, /** 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, kIfcFanTypeEnum_JET, /** Air flows through the impeller axially and small hub-to-tip ratio impeller mounted in an orifice plate or inlet ring.*/ kIfcFanTypeEnum_PROPELLORAXIAL, /** 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, /** User-defined fan type.*/ kIfcFanTypeEnum_USERDEFINED, /** Undefined fan type.*/ kIfcFanTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcFanTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcFanTypeEnum& getUnset() { static OdIfc4x4::IfcFanTypeEnum nullEnum = OdIfc4x4::kIfcFanTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcFastenerTypeEnum& getUnset() { static OdIfc4x4::IfcFastenerTypeEnum nullEnum = OdIfc4x4::kIfcFastenerTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { enum IfcFillElementTypeEnum { kIfcFillElementTypeEnum_ANNULARGAPFILL, kIfcFillElementTypeEnum_INVERTFILL, kIfcFillElementTypeEnum_USERDEFINED, kIfcFillElementTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcFillElementTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcFillElementTypeEnum& getUnset() { static OdIfc4x4::IfcFillElementTypeEnum nullEnum = OdIfc4x4::kIfcFillElementTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcFilterTypeEnum& getUnset() { static OdIfc4x4::IfcFilterTypeEnum nullEnum = OdIfc4x4::kIfcFilterTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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, /** Fire monitor.*/ kIfcFireSuppressionTerminalTypeEnum_FIREMONITOR, /** 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 OdIfc4x4::IfcFireSuppressionTerminalTypeEnum& getUnset() { static OdIfc4x4::IfcFireSuppressionTerminalTypeEnum nullEnum = OdIfc4x4::kIfcFireSuppressionTerminalTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration defines the flow direction at a distribution port. */ enum IfcFlowDirectionEnum { /** A flow sink, where a substance flows into the connection.*/ kIfcFlowDirectionEnum_SINK, /** A flow source, where a substance flows out of the connection.*/ kIfcFlowDirectionEnum_SOURCE, /** 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 OdIfc4x4::IfcFlowDirectionEnum& getUnset() { static OdIfc4x4::IfcFlowDirectionEnum nullEnum = OdIfc4x4::kIfcFlowDirectionEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details The IfcFlowInstrumentTypeEnum defines the range of different types of flow instrument that can be specified. */ enum IfcFlowInstrumentTypeEnum { /** A device that reads and displays the current flow in a circuit.*/ kIfcFlowInstrumentTypeEnum_AMMETER, /** A device that reads and displays the value of multiple properties of a system at a point, or displays the difference in the value of a property between two points.*/ kIfcFlowInstrumentTypeEnum_COMBINED, /** A device that reads and displays the electrical frequency of an alternating current circuit.*/ kIfcFlowInstrumentTypeEnum_FREQUENCYMETER, /** 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 power factor of an electrical circuit.*/ kIfcFlowInstrumentTypeEnum_POWERFACTORMETER, /** 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 measures and displays the voltage in a circuit.*/ kIfcFlowInstrumentTypeEnum_VOLTMETER, /** 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 OdIfc4x4::IfcFlowInstrumentTypeEnum& getUnset() { static OdIfc4x4::IfcFlowInstrumentTypeEnum nullEnum = OdIfc4x4::kIfcFlowInstrumentTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcFlowMeterTypeEnum& getUnset() { static OdIfc4x4::IfcFlowMeterTypeEnum nullEnum = OdIfc4x4::kIfcFlowMeterTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcFootingTypeEnum& getUnset() { static OdIfc4x4::IfcFootingTypeEnum nullEnum = OdIfc4x4::kIfcFootingTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details IfcFurnitureTypeEnum defines the types of furniture from which the type required can be selected. */ enum IfcFurnitureTypeEnum { /** Furniture for sleeping.*/ kIfcFurnitureTypeEnum_BED, /** Furniture for seating a single person.*/ kIfcFurnitureTypeEnum_CHAIR, /** Furniture with a countertop and optional drawers for a single person.*/ kIfcFurnitureTypeEnum_DESK, /** 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, /** Furniture with a countertop for multiple people.*/ kIfcFurnitureTypeEnum_TABLE, /** A technical cabinet is a piece of furniture for holding, displaying and protecting technical appliances, usually organized in shelves, drawers or racks.*/ kIfcFurnitureTypeEnum_TECHNICALCABINET, /** User-defined type.*/ kIfcFurnitureTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcFurnitureTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcFurnitureTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcFurnitureTypeEnum& getUnset() { static OdIfc4x4::IfcFurnitureTypeEnum nullEnum = OdIfc4x4::kIfcFurnitureTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { enum IfcGeoScienceFeatureTypeEnum { kIfcGeoScienceFeatureTypeEnum_CONTACT, kIfcGeoScienceFeatureTypeEnum_DISCRETEDISCONTINUITY, kIfcGeoScienceFeatureTypeEnum_FAULT, kIfcGeoScienceFeatureTypeEnum_FLUIDBODY, kIfcGeoScienceFeatureTypeEnum_FOLD, kIfcGeoScienceFeatureTypeEnum_GEOLOGICUNIT, kIfcGeoScienceFeatureTypeEnum_GEOTECHNICALUNIT, kIfcGeoScienceFeatureTypeEnum_HAZARDAREA, kIfcGeoScienceFeatureTypeEnum_HYDROGEOUNIT, kIfcGeoScienceFeatureTypeEnum_PHYSICALPROPERTYDISTRIBUTION, kIfcGeoScienceFeatureTypeEnum_PIEZOMETRICWATERLEVEL, kIfcGeoScienceFeatureTypeEnum_VOIDBODY, kIfcGeoScienceFeatureTypeEnum_USERDEFINED, kIfcGeoScienceFeatureTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcGeoScienceFeatureTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcGeoScienceFeatureTypeEnum& getUnset() { static OdIfc4x4::IfcGeoScienceFeatureTypeEnum nullEnum = OdIfc4x4::kIfcGeoScienceFeatureTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { enum IfcGeoScienceModelTypeEnum { kIfcGeoScienceModelTypeEnum_GEOHAZARDMODEL, kIfcGeoScienceModelTypeEnum_GEOLOGYMODEL, kIfcGeoScienceModelTypeEnum_GEOTECHMODEL, kIfcGeoScienceModelTypeEnum_GEOTECHSYNTHESISMODEL, kIfcGeoScienceModelTypeEnum_HYDROGEOMODEL, kIfcGeoScienceModelTypeEnum_PHYSICALPROPERTYDISTIBUTIONMODEL, kIfcGeoScienceModelTypeEnum_USERDEFINED, kIfcGeoScienceModelTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcGeoScienceModelTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcGeoScienceModelTypeEnum& getUnset() { static OdIfc4x4::IfcGeoScienceModelTypeEnum nullEnum = OdIfc4x4::kIfcGeoScienceModelTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { enum IfcGeoScienceObservationTypeEnum { kIfcGeoScienceObservationTypeEnum_BOREHOLELOG, kIfcGeoScienceObservationTypeEnum_GEOPHYSICALSURVEYRESULT, kIfcGeoScienceObservationTypeEnum_INSITUTESTRESULT, kIfcGeoScienceObservationTypeEnum_LABTESTRESULT, kIfcGeoScienceObservationTypeEnum_LOCALINFORMATION, kIfcGeoScienceObservationTypeEnum_MAPPEDFEATURE, kIfcGeoScienceObservationTypeEnum_USERDEFINED, kIfcGeoScienceObservationTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcGeoScienceObservationTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcGeoScienceObservationTypeEnum& getUnset() { static OdIfc4x4::IfcGeoScienceObservationTypeEnum nullEnum = OdIfc4x4::kIfcGeoScienceObservationTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration defines the different predefined types of geographic elements that can further specify an IfcGeographicElement or an IfcGeographicElementType. */ enum IfcGeographicElementTypeEnum { /** Soil boring point*/ kIfcGeographicElementTypeEnum_SOIL_BORING_POINT, /** Terrain*/ kIfcGeographicElementTypeEnum_TERRAIN, /** Plant life or plant cover (as of an area). For example trees, shrubs, herbs, grasses, ferns, and mosses.*/ kIfcGeographicElementTypeEnum_VEGETATION, /** User defined*/ kIfcGeographicElementTypeEnum_USERDEFINED, /** Not defined*/ kIfcGeographicElementTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcGeographicElementTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcGeographicElementTypeEnum& getUnset() { static OdIfc4x4::IfcGeographicElementTypeEnum nullEnum = OdIfc4x4::kIfcGeographicElementTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 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, /** 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 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 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, /** 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 OdIfc4x4::IfcGeometricProjectionEnum& getUnset() { static OdIfc4x4::IfcGeometricProjectionEnum nullEnum = OdIfc4x4::kIfcGeometricProjectionEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This container defines the different predefined types of stratum elements that can further specify an IfcGeotechnicalStratum. */ enum IfcGeotechnicalStratumTypeEnum { /** Representation of the concept of an identified discrete almost homogenous solid geological or surface feature, including discontinuities such as faults, fractures, boundaries and interfaces that are not explicitly modeled.*/ kIfcGeotechnicalStratumTypeEnum_SOLID, /** Representation of the concept of an identified discrete air filled geological feature, including caves and other voids.*/ kIfcGeotechnicalStratumTypeEnum_VOID, /** Representation of the concept of an identified discrete water filled geological or surface feature including lakes, rivers and seas.*/ kIfcGeotechnicalStratumTypeEnum_WATER, /** No description available.*/ kIfcGeotechnicalStratumTypeEnum_USERDEFINED, /** No description available.*/ kIfcGeotechnicalStratumTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcGeotechnicalStratumTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcGeotechnicalStratumTypeEnum& getUnset() { static OdIfc4x4::IfcGeotechnicalStratumTypeEnum nullEnum = OdIfc4x4::kIfcGeotechnicalStratumTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcGlobalOrLocalEnum& getUnset() { static OdIfc4x4::IfcGlobalOrLocalEnum nullEnum = OdIfc4x4::kIfcGlobalOrLocalEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 u-axes, v-axes, and optionally w-axes that cannot be described by the patterns.*/ kIfcGridTypeEnum_IRREGULAR, /** 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 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 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, /** 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 OdIfc4x4::IfcGridTypeEnum& getUnset() { static OdIfc4x4::IfcGridTypeEnum nullEnum = OdIfc4x4::kIfcGridTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { enum IfcGroundReinforcementElementTypeEnum { kIfcGroundReinforcementElementTypeEnum_BAR, kIfcGroundReinforcementElementTypeEnum_BOLT, kIfcGroundReinforcementElementTypeEnum_FABRIC, kIfcGroundReinforcementElementTypeEnum_PILE, kIfcGroundReinforcementElementTypeEnum_PLATE, kIfcGroundReinforcementElementTypeEnum_TENDON, kIfcGroundReinforcementElementTypeEnum_TUBE, kIfcGroundReinforcementElementTypeEnum_USERDEFINED, kIfcGroundReinforcementElementTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcGroundReinforcementElementTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcGroundReinforcementElementTypeEnum& getUnset() { static OdIfc4x4::IfcGroundReinforcementElementTypeEnum nullEnum = OdIfc4x4::kIfcGroundReinforcementElementTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details Enumeration defining the typical types of heat exchangers. */ enum IfcHeatExchangerTypeEnum { /** Plate heat exchanger.*/ kIfcHeatExchangerTypeEnum_PLATE, /** Shell and Tube heat exchanger.*/ kIfcHeatExchangerTypeEnum_SHELLANDTUBE, /** A device used to remove snow from railways. E.g. electric heating device, gas heater*/ kIfcHeatExchangerTypeEnum_TURNOUTHEATING, /** 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 OdIfc4x4::IfcHeatExchangerTypeEnum& getUnset() { static OdIfc4x4::IfcHeatExchangerTypeEnum nullEnum = OdIfc4x4::kIfcHeatExchangerTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details Enumeration defining the typical types of humidifiers. */ enum IfcHumidifierTypeEnum { /** 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 an atomizing element.*/ kIfcHumidifierTypeEnum_ADIABATICATOMIZING, /** 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 adiabatic evaporation using a pan.*/ kIfcHumidifierTypeEnum_ADIABATICPAN, /** 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 an ultrasonic element.*/ kIfcHumidifierTypeEnum_ADIABATICULTRASONIC, /** Water vapor is added into the airstream through adiabatic evaporation using a wetted element.*/ kIfcHumidifierTypeEnum_ADIABATICWETTEDELEMENT, /** 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 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 steam heater.*/ kIfcHumidifierTypeEnum_ASSISTEDSTEAM, /** Water vapor is added into the airstream through direct steam injection.*/ kIfcHumidifierTypeEnum_STEAMINJECTION, /** User-defined humidifier type.*/ kIfcHumidifierTypeEnum_USERDEFINED, /** Undefined humidifier type.*/ kIfcHumidifierTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcHumidifierTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcHumidifierTypeEnum& getUnset() { static OdIfc4x4::IfcHumidifierTypeEnum nullEnum = OdIfc4x4::kIfcHumidifierTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This container defines the different predefined types of kinetic impact protectors that can specify an IfcImpactProtectionDevice or IfcImpactProtectionDeviceType. */ enum IfcImpactProtectionDeviceTypeEnum { /** A bumper is a buffer object at end of track that prevents driving over. It can be fixed on rails or the track panel, or can also be a natural element (e.g. rock, sand).*/ kIfcImpactProtectionDeviceTypeEnum_BUMPER, /** Road vehicle energy absorption device installed in front of one or more hazards to reduce the severity of impact.*/ kIfcImpactProtectionDeviceTypeEnum_CRASHCUSHION, /** An elastic element inserted between the superstructure (track and plate on slab track or ballast bed with ballast inserted in) and the tunnel structure (tunnel floor). Some of the elastic elements have a partial decoupling effect between the superstructure and underground due to vibrations. Both helical springs and elastomer blocks or elastomer strips can be used as suspension systems.*/ kIfcImpactProtectionDeviceTypeEnum_DAMPINGSYSTEM, /** A passive or active device formed of a damper and impact panel that is mounted on the quayside to protect against vessel impact.*/ kIfcImpactProtectionDeviceTypeEnum_FENDER, /** User-defined type*/ kIfcImpactProtectionDeviceTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcImpactProtectionDeviceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcImpactProtectionDeviceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcImpactProtectionDeviceTypeEnum& getUnset() { static OdIfc4x4::IfcImpactProtectionDeviceTypeEnum nullEnum = OdIfc4x4::kIfcImpactProtectionDeviceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { enum IfcImprovedGroundTypeEnum { kIfcImprovedGroundTypeEnum_DEEPMIXED, kIfcImprovedGroundTypeEnum_DEWATERED, kIfcImprovedGroundTypeEnum_DYNAMICALLYCOMPACTED, kIfcImprovedGroundTypeEnum_FROZEN, kIfcImprovedGroundTypeEnum_INJECTIONGROUTED, kIfcImprovedGroundTypeEnum_JETGROUTED, kIfcImprovedGroundTypeEnum_LATERALLYDRAINED, kIfcImprovedGroundTypeEnum_REPLACED, kIfcImprovedGroundTypeEnum_ROLLERCOMPACTED, kIfcImprovedGroundTypeEnum_SURCHARGEPRELOADED, kIfcImprovedGroundTypeEnum_VERTICALLYDRAINED, kIfcImprovedGroundTypeEnum_USERDEFINED, kIfcImprovedGroundTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcImprovedGroundTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcImprovedGroundTypeEnum& getUnset() { static OdIfc4x4::IfcImprovedGroundTypeEnum nullEnum = OdIfc4x4::kIfcImprovedGroundTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcInterceptorTypeEnum& getUnset() { static OdIfc4x4::IfcInterceptorTypeEnum nullEnum = OdIfc4x4::kIfcInterceptorTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 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 another building on the other side.*/ kIfcInternalOrExternalEnum_EXTERNAL_FIRE, /** 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 an internal space on the other side.*/ kIfcInternalOrExternalEnum_INTERNAL, /** No information available.*/ kIfcInternalOrExternalEnum_NOTDEFINED, /** The value is unset.*/ kIfcInternalOrExternalEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcInternalOrExternalEnum& getUnset() { static OdIfc4x4::IfcInternalOrExternalEnum nullEnum = OdIfc4x4::kIfcInternalOrExternalEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 furniture instances of type IfcFurnishingElement.*/ kIfcInventoryTypeEnum_FURNITUREINVENTORY, /** A collection of space instances of type IfcSpace.*/ kIfcInventoryTypeEnum_SPACEINVENTORY, /** User-defined type.*/ kIfcInventoryTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcInventoryTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcInventoryTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcInventoryTypeEnum& getUnset() { static OdIfc4x4::IfcInventoryTypeEnum nullEnum = OdIfc4x4::kIfcInventoryTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcJunctionBoxTypeEnum& getUnset() { static OdIfc4x4::IfcJunctionBoxTypeEnum nullEnum = OdIfc4x4::kIfcJunctionBoxTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details The predefined type container that collects kerb types together into the implemented enumeration. */ enum IfcKerbTypeEnum { /** User-defined type.*/ kIfcKerbTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcKerbTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcKerbTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcKerbTypeEnum& getUnset() { static OdIfc4x4::IfcKerbTypeEnum nullEnum = OdIfc4x4::kIfcKerbTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details The IfcKnotType indicates the particular form of b-spline knots. */ enum IfcKnotType { /** The form of knots appropriate for a piecewise Bezier curve.*/ kIfcKnotType_PIECEWISE_BEZIER_KNOTS, /** The form of knots appropriate for a quasi-uniform B-spline curve.*/ kIfcKnotType_QUASI_UNIFORM_KNOTS, /** The form of knots appropriate for a uniform B-spline curve.*/ kIfcKnotType_UNIFORM_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 OdIfc4x4::IfcKnotType& getUnset() { static OdIfc4x4::IfcKnotType nullEnum = OdIfc4x4::kIfcKnotType_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcLaborResourceTypeEnum& getUnset() { static OdIfc4x4::IfcLaborResourceTypeEnum nullEnum = OdIfc4x4::kIfcLaborResourceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcLampTypeEnum& getUnset() { static OdIfc4x4::IfcLampTypeEnum nullEnum = OdIfc4x4::kIfcLampTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcLayerSetDirectionEnum& getUnset() { static OdIfc4x4::IfcLayerSetDirectionEnum nullEnum = OdIfc4x4::kIfcLayerSetDirectionEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcLightDistributionCurveEnum& getUnset() { static OdIfc4x4::IfcLightDistributionCurveEnum nullEnum = OdIfc4x4::kIfcLightDistributionCurveEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcLightEmissionSourceEnum& getUnset() { static OdIfc4x4::IfcLightEmissionSourceEnum nullEnum = OdIfc4x4::kIfcLightEmissionSourceEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details The IfcLightFixtureTypeEnum defines the different types of light fixtures. */ enum IfcLightFixtureTypeEnum { /** 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 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 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 OdIfc4x4::IfcLightFixtureTypeEnum& getUnset() { static OdIfc4x4::IfcLightFixtureTypeEnum nullEnum = OdIfc4x4::kIfcLightFixtureTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This container defines the different predefined types of liquid terminals that can further specify an IfcLiquidTerminal or IfcLiquidTerminalType. */ enum IfcLiquidTerminalTypeEnum { /** A Supporting framework on which a hose may be wound whose primary purpose is to connect and interact with the external environment.*/ kIfcLiquidTerminalTypeEnum_HOSEREEL, /** A loading arm permits the transfer of liquid or liquefied gas from one system to another, through the use of an articulated arm that accounts for the movement of docked vessels.*/ kIfcLiquidTerminalTypeEnum_LOADINGARM, /** User-defined type*/ kIfcLiquidTerminalTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcLiquidTerminalTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcLiquidTerminalTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcLiquidTerminalTypeEnum& getUnset() { static OdIfc4x4::IfcLiquidTerminalTypeEnum nullEnum = OdIfc4x4::kIfcLiquidTerminalTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 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, /** 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, /** 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 OdIfc4x4::IfcLoadGroupTypeEnum& getUnset() { static OdIfc4x4::IfcLoadGroupTypeEnum nullEnum = OdIfc4x4::kIfcLoadGroupTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 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, /** 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, /** The value is unset.*/ kIfcLogicalOperatorEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcLogicalOperatorEnum& getUnset() { static OdIfc4x4::IfcLogicalOperatorEnum nullEnum = OdIfc4x4::kIfcLogicalOperatorEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details The predefined type container that collects all possible marine facility types together into the implemented enumeration. */ enum IfcMarineFacilityTypeEnum { /** a sand ridge that rises slightly above the surface of the sea and runs roughly parallel to the shore, from which it is separated by a lagoon.*/ kIfcMarineFacilityTypeEnum_BARRIERBEACH, /** A longitudinal structure that protects a shore area, harbour, basin or estuary from waves.*/ kIfcMarineFacilityTypeEnum_BREAKWATER, /** A man-made watercourse constructed usually, to join rivers, lakes or seas and often of a size suitable for navigation.*/ kIfcMarineFacilityTypeEnum_CANAL, /** a Dry dock is an enclosed chamber (by gate) that allows the draining of water for the construction or repair of marine vessels.*/ kIfcMarineFacilityTypeEnum_DRYDOCK, /** A spatial element that encompasses a floating dry dock and supporting quay side ancillaries.*/ kIfcMarineFacilityTypeEnum_FLOATINGDOCK, /** A type of vessel launch recovery facility, also known as a hydraulic lift dock, where ships are lifted vertically by water impounding systems, then floated laterally across the land to berths which subsequently become dry.*/ kIfcMarineFacilityTypeEnum_HYDROLIFT, /** A berthing structure, that extends out into the sea usually perpendicular to the coastline, primarily for the transfer of liquid bulk materials.*/ kIfcMarineFacilityTypeEnum_JETTY, /** Subset of facilities for the function of launching or recovering vessels.*/ kIfcMarineFacilityTypeEnum_LAUNCHRECOVERY, /** A subset of facilities with the primary function of protection or defence of a coastal or flood area.*/ kIfcMarineFacilityTypeEnum_MARINEDEFENCE, /** A natural navigable watercourse (such as a river) that needs to be managed or have improvements applied. This includes defined navigational areas in open seas and bays. NOTE definition in ISO 6707: open passage for conveying or containing water*/ kIfcMarineFacilityTypeEnum_NAVIGATIONALCHANNEL, /** A complex/facility for shipping and marine activities, this includes cargo, people and storage of vessels (marinas harbours).*/ kIfcMarineFacilityTypeEnum_PORT, /** a facility for the mooring of vessels accompanied with the loading and unloading of cargo or passengers or the maintenance of vessels.*/ kIfcMarineFacilityTypeEnum_QUAY, /** A marine defensive structure made from earthworks, masonry or activities, built in such a way as to absorb the energy of incoming water.*/ kIfcMarineFacilityTypeEnum_REVETMENT, /** A type of vessel launch recovery facility, where ships are lifted vertically out of the water on platforms connected to winches, then transferred horizontally to land based berths on rail, wheel or track systems.*/ kIfcMarineFacilityTypeEnum_SHIPLIFT, /** A facility used for raising and lowering boats, ships and other watercraft between stretches of water of different levels on rivers and canal waterways or between impounded basins. This is achieved via an impounded chamber of water which is filled and emptied.*/ kIfcMarineFacilityTypeEnum_SHIPLOCK, /** A coastal/waterside facility where ships are built and repaired.*/ kIfcMarineFacilityTypeEnum_SHIPYARD, /** A facility for the dynamic launch or recovery of a vessel utilizing an inclined ramp and gravitational or mechanical hauling systems.*/ kIfcMarineFacilityTypeEnum_SLIPWAY, /** A subset of facilities that have the primary function of providing a navigable area of water.*/ kIfcMarineFacilityTypeEnum_WATERWAY, /** A facility used for raising and lowering boats, ships and other watercraft between stretches of water of different levels on river and canal waterways or between impounded basins. This is achieved via an impounded trough of water which is mechanically lifted up and down.*/ kIfcMarineFacilityTypeEnum_WATERWAYSHIPLIFT, /** User-defined type*/ kIfcMarineFacilityTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcMarineFacilityTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcMarineFacilityTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcMarineFacilityTypeEnum& getUnset() { static OdIfc4x4::IfcMarineFacilityTypeEnum nullEnum = OdIfc4x4::kIfcMarineFacilityTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details The predefined type container that collects all possible marine facility part types together into the implemented enumeration. */ enum IfcMarinePartTypeEnum { /** A vertical spatial part that represents the part above the mean waterline defined within the site area.*/ kIfcMarinePartTypeEnum_ABOVEWATERLINE, /** A region spatial part that represents a managed area for the anchorage of vessels awaiting space and conditions to enter a port.*/ kIfcMarinePartTypeEnum_ANCHORAGE, /** A longitudinal spatial part of a waterway or port facility that covers the approach of the primary facility.*/ kIfcMarinePartTypeEnum_APPROACHCHANNEL, /** A vertical spatial part that represents the part below the mean waterline defined within the site area.*/ kIfcMarinePartTypeEnum_BELOWWATERLINE, /** A longitudinal spatial part of a waterway or port facility that provides facilities for the berthing of vessels while waiting for the waterway facility to become available. For example waiting for a lock cycle to complete and the lock gates to open.*/ kIfcMarinePartTypeEnum_BERTHINGSTRUCTURE, /** A longitudinal spatial part of a waterway or port facility that forms the impounded chamber of a facility, such as a ship lock, dry dock or hydrolift*/ kIfcMarinePartTypeEnum_CHAMBER, /** A vertical spatial part that represents the elevation of the cill and floor level of an impounded facility such as a ship lock or dry lock.*/ kIfcMarinePartTypeEnum_CILL_LEVEL, /** A vertical spatial part that represents the elevation working surface of the quay for the placement of quay furniture and plant.*/ kIfcMarinePartTypeEnum_COPELEVEL, /** A lateral spatial part that sub divides the core structure of a facility such as a breakwater or embankment*/ kIfcMarinePartTypeEnum_CORE, /** A lateral spatial part that forms the crest area of breakwater or embankment where additional structures are placed such as access items or roads.*/ kIfcMarinePartTypeEnum_CREST, /** A longitudinal spatial part of a waterway or port facility that forms the gate, supporting structure plant of an impounded facility such as a ship lock, dry dock or hydrolift.*/ kIfcMarinePartTypeEnum_GATEHEAD, /** A longitudinal spatial part of a waterway or port facility that forms the guiding and assistive structures at the entrance to an impounded facility.*/ kIfcMarinePartTypeEnum_GUDINGSTRUCTURE, /** A vertical spatial part that represents the elevation of the high waterline, multiple high waterlines can be used to represent the different high tide types.*/ kIfcMarinePartTypeEnum_HIGHWATERLINE, /** A region or lateral facility part that covers the land field of a waterside facility such as a quay.*/ kIfcMarinePartTypeEnum_LANDFIELD, /** A lateral spatial part that covers the side of protective structures that do not experience weather or wave effects.*/ kIfcMarinePartTypeEnum_LEEWARDSIDE, /** A vertical spatial part that represents the elevation of the low waterline, multiple low waterlines can be used to represent the different low tide types.*/ kIfcMarinePartTypeEnum_LOWWATERLINE, /** A region spatial part that forms a sub division of a facility for the purpose of manufacturing. This covers areas that are open air and do not constitute a building or the building is only a small part of the entire area (in this case a child of type building can be used).*/ kIfcMarinePartTypeEnum_MANUFACTURING, /** A region spatial part that covers a managed navigational area that is maintained for an operational reason, this could be a dredged turning circle or waiting area.*/ kIfcMarinePartTypeEnum_NAVIGATIONALAREA, /** A lateral or region spatial part that forms the area which contains protective measures for scour and erosion of a facility.*/ kIfcMarinePartTypeEnum_PROTECTION, /** A region spatial part that represents a clear area used for the transfer and movement of vessels this area could include complex rail tracks and additional loading requirements.*/ kIfcMarinePartTypeEnum_SHIPTRANSFER, /** A region spatial part that forms a sub division of a facility for the purpose of storing cargo. For example container stacks, dry bulk storage yards, material storage yards.*/ kIfcMarinePartTypeEnum_STORAGEAREA, /** A region spatial part that represents a functional division designed for the maintenance and/or storage of vehicles used for facility operations.*/ kIfcMarinePartTypeEnum_VEHICLESERVICING, /** A region or lateral facility part that covers the water field of a waterside facility such as a quay.*/ kIfcMarinePartTypeEnum_WATERFIELD, /** A lateral spatial part that covers the side of protective structures that is designed to protect and be impacted by weather or wave effects. such as the outer side of breakwaters or the riverside of flood embankments.*/ kIfcMarinePartTypeEnum_WEATHERSIDE, /** User-defined type*/ kIfcMarinePartTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcMarinePartTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcMarinePartTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcMarinePartTypeEnum& getUnset() { static OdIfc4x4::IfcMarinePartTypeEnum nullEnum = OdIfc4x4::kIfcMarinePartTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 series of linked metal rings used for fastening or securing something, or for pulling loads.*/ kIfcMechanicalFastenerTypeEnum_CHAIN, /** A part connecting two rod or bars, such as reinforcement bars.*/ kIfcMechanicalFastenerTypeEnum_COUPLER, /** 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, /** An assembly of components which secures a rail to the supporting structure and retains it in the required position whilst permitting any necessary vertical, lateral and longitudinal movement.*/ kIfcMechanicalFastenerTypeEnum_RAILFASTENING, /** A mechanical assembly with e.g. fishplates to join two rail ends with optional functions (insulation or expansion capacity).*/ kIfcMechanicalFastenerTypeEnum_RAILJOINT, /** 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 length of thick strong cord made by twisting together strands of hemp, sisal, nylon, or similar material. used primarily for mooring vessels*/ kIfcMechanicalFastenerTypeEnum_ROPE, /** 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, /** User-defined mechanical fastener.*/ kIfcMechanicalFastenerTypeEnum_USERDEFINED, /** Undefined mechanical fastener.*/ kIfcMechanicalFastenerTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcMechanicalFastenerTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcMechanicalFastenerTypeEnum& getUnset() { static OdIfc4x4::IfcMechanicalFastenerTypeEnum nullEnum = OdIfc4x4::kIfcMechanicalFastenerTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcMedicalDeviceTypeEnum& getUnset() { static OdIfc4x4::IfcMedicalDeviceTypeEnum nullEnum = OdIfc4x4::kIfcMedicalDeviceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration defines the different types of linear elements an IfcMember or IfcMemberType object can fulfill. */ enum IfcMemberTypeEnum { /** Individual segment of an arch structure.*/ kIfcMemberTypeEnum_ARCH_SEGMENT, /** 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 sloped element suspending a structure (such as bridge deck) from a pylon.*/ kIfcMemberTypeEnum_STAY_CABLE, /** A linear element added to a flange or a web plate of a girder for local stiffening.*/ kIfcMemberTypeEnum_STIFFENING_RIB, /** A linear element used to support stair or ramp flights, usually used with slope.*/ kIfcMemberTypeEnum_STRINGER, /** A linear cable element used to secure or stabilise a structure by resisting lateral and longitudinal loading through tension only, but cannot resist compression. usually formed of a flexible cable or wire.*/ kIfcMemberTypeEnum_STRUCTURALCABLE, /** A linear element often used within a girder or truss.*/ kIfcMemberTypeEnum_STRUT, /** Vertical element in wall framing.*/ kIfcMemberTypeEnum_STUD, /** A vertical element suspending a structure (such as bridge deck) from a suspension cable or an arch.*/ kIfcMemberTypeEnum_SUSPENDER, /** A suspended element, typically comprising steel wire, sheath, etc.*/ kIfcMemberTypeEnum_SUSPENSION_CABLE, /** A linear bar element used to secure or stabilise a structure by resisting lateral and longitudinal loading through tension and or compression. usually formed by a solid bar.*/ kIfcMemberTypeEnum_TIEBAR, /** User-defined linear element.*/ kIfcMemberTypeEnum_USERDEFINED, /** Undefined linear element.*/ kIfcMemberTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcMemberTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcMemberTypeEnum& getUnset() { static OdIfc4x4::IfcMemberTypeEnum nullEnum = OdIfc4x4::kIfcMemberTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details The IfcMobileTelecommunicationsApplianceTypeEnum defines the range of different types of mobile telecommunications appliance that can be specified. */ enum IfcMobileTelecommunicationsApplianceTypeEnum { /** An access point is a device that allows wireless devices to connect to a wired network.*/ kIfcMobileTelecommunicationsApplianceTypeEnum_ACCESSPOINT, /** A baseband unit is a component of a distributed base transceiver station for implementing baseband processing functions.*/ kIfcMobileTelecommunicationsApplianceTypeEnum_BASEBANDUNIT, /** A base transceiver station (BTS) is a network component which serves one cell. It completes the conversion between base station controller and wireless channel, and realizes the wireless transmission and related control functions between base station controller and mobile switching through the air interface.*/ kIfcMobileTelecommunicationsApplianceTypeEnum_BASETRANSCEIVERSTATION, /** An E-utran nodel B is a logical network component which serves one or more E-utran cells. It is the hardware connected to the evolved packet core (EPC), more specifically to the mobility management entity (MME) , which communicates directly with user equipment in wireless way.*/ kIfcMobileTelecommunicationsApplianceTypeEnum_E_UTRAN_NODE_B, /** The gateway GPRS support node is a component of the GPRS core network that extends the GSM to allow packet switching functionalities. This component is responsible for the internetworking between the GPRS network and external packet switched networks (e.g. the internet).*/ kIfcMobileTelecommunicationsApplianceTypeEnum_GATEWAY_GPRS_SUPPORT_NODE, /** A master unit is a component of a repeater for coupling base station signals.*/ kIfcMobileTelecommunicationsApplianceTypeEnum_MASTERUNIT, /** The mobile switching centre (MSC) constitutes the interface between the radio system and the fixed networks. It is an exchange which performs all the switching and signalling functions for mobile station located in a geographical area designated as the MSC area. It consists of a MSC server and a media gateway.*/ kIfcMobileTelecommunicationsApplianceTypeEnum_MOBILESWITCHINGCENTER, /** The MSC server mainly comprises the call control (CC) and mobility control parts of a mobile switching center (MSC). An MSC server and a media gateway make up the full functionality of an MSC.*/ kIfcMobileTelecommunicationsApplianceTypeEnum_MSCSERVER, /** A packet control unit performs some of the processing tasks of the base station controller for packet data. It is responsible for data packet, wireless channel management, error sending detection and automatic retransmission.*/ kIfcMobileTelecommunicationsApplianceTypeEnum_PACKETCONTROLUNIT, /** A remote radio unit is a component of a distributed base transceiver station that converts digital baseband signals into high-frequency (rf) signals and sends high-frequency (rf) signals to the antenna for radiation.*/ kIfcMobileTelecommunicationsApplianceTypeEnum_REMOTERADIOUNIT, /** A remote unit is a device used to amplify a base station signal.*/ kIfcMobileTelecommunicationsApplianceTypeEnum_REMOTEUNIT, /** The service GPRS support node (SGSN) is a component of the GPRS core network. It is the GPRS support node of mobile station service, and it can achieve mobility management and packet routing and transfer.*/ kIfcMobileTelecommunicationsApplianceTypeEnum_SERVICE_GPRS_SUPPORT_NODE, /** It is a database in charge of the management of mobile subscribers. It can be an authentication center (AuC) or a home location register (HLR).*/ kIfcMobileTelecommunicationsApplianceTypeEnum_SUBSCRIBERSERVER, /** User-defined type*/ kIfcMobileTelecommunicationsApplianceTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcMobileTelecommunicationsApplianceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcMobileTelecommunicationsApplianceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcMobileTelecommunicationsApplianceTypeEnum& getUnset() { static OdIfc4x4::IfcMobileTelecommunicationsApplianceTypeEnum nullEnum = OdIfc4x4::kIfcMobileTelecommunicationsApplianceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This container defines the different predefined types of mooring elements that can further specify an IfcMooringDevice _ or IfcMooringDeviceType. */ enum IfcMooringDeviceTypeEnum { /** a short, thick post on the deck of a ship or a quay side, to which ship's rope may be secured. not to be confused with traffic bollards.*/ kIfcMooringDeviceTypeEnum_BOLLARD, /** A mechanical device used to apply a tensioning load to mooring lines to improve vessel stability for port operations.*/ kIfcMooringDeviceTypeEnum_LINETENSIONER, /** Mooring device that uses magnets as the primary method of securing the vessel.*/ kIfcMooringDeviceTypeEnum_MAGNETICDEVICE, /** Quick release mooring hooks - an active device used to secure a vessel and provide automated release of vessels.*/ kIfcMooringDeviceTypeEnum_MOORINGHOOKS, /** Mooring device that uses vacuum suction as the primary method of securing the vessel.*/ kIfcMooringDeviceTypeEnum_VACUUMDEVICE, /** User-defined type*/ kIfcMooringDeviceTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcMooringDeviceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcMooringDeviceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcMooringDeviceTypeEnum& getUnset() { static OdIfc4x4::IfcMooringDeviceTypeEnum nullEnum = OdIfc4x4::kIfcMooringDeviceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcMotorConnectionTypeEnum& getUnset() { static OdIfc4x4::IfcMotorConnectionTypeEnum nullEnum = OdIfc4x4::kIfcMotorConnectionTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This container defines the different predefined types of navigation elements that can further specify an IfcNavigationElement or IfcNavigationElementType. */ enum IfcNavigationElementTypeEnum { /** a fixed vertical structure serving as a navigation mark, to show reefs or other hazards, or provide navigational directions.*/ kIfcNavigationElementTypeEnum_BEACON, /** an anchored floating structure serving as a navigation mark, to show reefs or other hazards, or provide navigational directions.*/ kIfcNavigationElementTypeEnum_BUOY, /** User-defined type*/ kIfcNavigationElementTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcNavigationElementTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcNavigationElementTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcNavigationElementTypeEnum& getUnset() { static OdIfc4x4::IfcNavigationElementTypeEnum nullEnum = OdIfc4x4::kIfcNavigationElementTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcObjectiveEnum& getUnset() { static OdIfc4x4::IfcObjectiveEnum nullEnum = OdIfc4x4::kIfcObjectiveEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcOccupantTypeEnum& getUnset() { static OdIfc4x4::IfcOccupantTypeEnum nullEnum = OdIfc4x4::kIfcOccupantTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcOpeningElementTypeEnum& getUnset() { static OdIfc4x4::IfcOpeningElementTypeEnum nullEnum = OdIfc4x4::kIfcOpeningElementTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 data communications equipment.*/ kIfcOutletTypeEnum_DATAOUTLET, /** An outlet used for connecting electrical devices requiring power.*/ kIfcOutletTypeEnum_POWEROUTLET, /** 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 OdIfc4x4::IfcOutletTypeEnum& getUnset() { static OdIfc4x4::IfcOutletTypeEnum nullEnum = OdIfc4x4::kIfcOutletTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This container defines the different predefined types of course elements that can further specify an IfcPavement or IfcPavementType. */ enum IfcPavementTypeEnum { /** Pavement with a bituminous surfacing and with a base layer with or without a hydrocarbon binder.*/ kIfcPavementTypeEnum_FLEXIBLE, /** Pavement substantially constructed of cement concrete.*/ kIfcPavementTypeEnum_RIGID, /** User-defined type.*/ kIfcPavementTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcPavementTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcPavementTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcPavementTypeEnum& getUnset() { static OdIfc4x4::IfcPavementTypeEnum nullEnum = OdIfc4x4::kIfcPavementTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcPerformanceHistoryTypeEnum& getUnset() { static OdIfc4x4::IfcPerformanceHistoryTypeEnum nullEnum = OdIfc4x4::kIfcPerformanceHistoryTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcPermeableCoveringOperationEnum& getUnset() { static OdIfc4x4::IfcPermeableCoveringOperationEnum nullEnum = OdIfc4x4::kIfcPermeableCoveringOperationEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcPermitTypeEnum& getUnset() { static OdIfc4x4::IfcPermitTypeEnum nullEnum = OdIfc4x4::kIfcPermitTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcPhysicalOrVirtualEnum& getUnset() { static OdIfc4x4::IfcPhysicalOrVirtualEnum nullEnum = OdIfc4x4::kIfcPhysicalOrVirtualEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcPileConstructionEnum& getUnset() { static OdIfc4x4::IfcPileConstructionEnum nullEnum = OdIfc4x4::kIfcPileConstructionEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details Enumeration defining the pile type. */ enum IfcPileTypeEnum { /** A bore pile.*/ kIfcPileTypeEnum_BORED, /** A cohesion pile.*/ kIfcPileTypeEnum_COHESION, /** A rammed, vibrated, or otherwise driven pile.*/ kIfcPileTypeEnum_DRIVEN, /** A friction pile.*/ kIfcPileTypeEnum_FRICTION, /** An injected pile-like construction.*/ kIfcPileTypeEnum_JETGROUTING, /** 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 OdIfc4x4::IfcPileTypeEnum& getUnset() { static OdIfc4x4::IfcPileTypeEnum nullEnum = OdIfc4x4::kIfcPileTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcPipeFittingTypeEnum& getUnset() { static OdIfc4x4::IfcPipeFittingTypeEnum nullEnum = OdIfc4x4::kIfcPipeFittingTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 gutter segment is a continuous open-channel segment of pipe.*/ kIfcPipeSegmentTypeEnum_GUTTER, /** A rigid segment is continuous linear segment of pipe that cannot be deformed.*/ kIfcPipeSegmentTypeEnum_RIGIDSEGMENT, /** 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 OdIfc4x4::IfcPipeSegmentTypeEnum& getUnset() { static OdIfc4x4::IfcPipeSegmentTypeEnum nullEnum = OdIfc4x4::kIfcPipeSegmentTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration defines the different types of planar elements an IfcPlate or IfcPlateType object can fulfill. */ enum IfcPlateTypeEnum { /** A plate used to spread load over a surface, such as underneath a bearing or column.*/ kIfcPlateTypeEnum_BASE_PLATE, /** A plate (underneath or above) a flange to provide additional load capacity.*/ kIfcPlateTypeEnum_COVER_PLATE, /** A planar element within a curtain wall, often consisting of a frame with fixed glazing.*/ kIfcPlateTypeEnum_CURTAIN_PANEL, /** 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 or bracket for strengthening an angle in framework (as in a building or bridge).*/ kIfcPlateTypeEnum_GUSSET_PLATE, kIfcPlateTypeEnum_LAGGING, /** 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 plate connecting two members joined at ends.*/ kIfcPlateTypeEnum_SPLICE_PLATE, /** A transversal plate added to a flange or a web plate for local stiffening.*/ kIfcPlateTypeEnum_STIFFENER_PLATE, /** A plate connecting flange plates in linear members having box or I-profile.*/ kIfcPlateTypeEnum_WEB_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 OdIfc4x4::IfcPlateTypeEnum& getUnset() { static OdIfc4x4::IfcPlateTypeEnum nullEnum = OdIfc4x4::kIfcPlateTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcPreferredSurfaceCurveRepresentation& getUnset() { static OdIfc4x4::IfcPreferredSurfaceCurveRepresentation nullEnum = OdIfc4x4::kIfcPreferredSurfaceCurveRepresentation_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcProcedureTypeEnum& getUnset() { static OdIfc4x4::IfcProcedureTypeEnum nullEnum = OdIfc4x4::kIfcProcedureTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 surface. The resulting geometry after applying a sweeping operation is a swept solid with defined volume.*/ kIfcProfileTypeEnum_AREA, /** 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 value is unset.*/ kIfcProfileTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcProfileTypeEnum& getUnset() { static OdIfc4x4::IfcProfileTypeEnum nullEnum = OdIfc4x4::kIfcProfileTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcProjectOrderTypeEnum& getUnset() { static OdIfc4x4::IfcProjectOrderTypeEnum nullEnum = OdIfc4x4::kIfcProjectOrderTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcProjectedOrTrueLengthEnum& getUnset() { static OdIfc4x4::IfcProjectedOrTrueLengthEnum nullEnum = OdIfc4x4::kIfcProjectedOrTrueLengthEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcProjectionElementTypeEnum& getUnset() { static OdIfc4x4::IfcProjectionElementTypeEnum nullEnum = OdIfc4x4::kIfcProjectionElementTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 are to be encoded in an IfcMaterialProperties entity and assigned to an IfcMaterialDefinition.*/ kIfcPropertySetTemplateTypeEnum_PSET_MATERIALDRIVEN, /** 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 property sets defined by this IfcPropertySetTemplate are to be encoded in an IfcProfileProperties entity and assigned to an IfcProfileDef.*/ kIfcPropertySetTemplateTypeEnum_PSET_PROFILEDRIVEN, /** 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 element quantity defined by this IfcPropertySetTemplate can only be assigned to subtypes of IfcObject.*/ kIfcPropertySetTemplateTypeEnum_QTO_OCCURRENCEDRIVEN, /** 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, /** 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 OdIfc4x4::IfcPropertySetTemplateTypeEnum& getUnset() { static OdIfc4x4::IfcPropertySetTemplateTypeEnum nullEnum = OdIfc4x4::kIfcPropertySetTemplateTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 electromagnetic action.*/ kIfcProtectiveDeviceTrippingUnitTypeEnum_ELECTROMAGNETIC, /** A tripping unit activated by electronic action.*/ kIfcProtectiveDeviceTrippingUnitTypeEnum_ELECTRONIC, /** 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 OdIfc4x4::IfcProtectiveDeviceTrippingUnitTypeEnum& getUnset() { static OdIfc4x4::IfcProtectiveDeviceTrippingUnitTypeEnum nullEnum = OdIfc4x4::kIfcProtectiveDeviceTrippingUnitTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 { /** An anti-arcing device is an equipment that prevents electric arc.*/ kIfcProtectiveDeviceTypeEnum_ANTI_ARCING_DEVICE, /** 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 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 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 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 spark gap is a device used to connect a circuit to earth in the event of a fault in live circuits.*/ kIfcProtectiveDeviceTypeEnum_SPARKGAP, /** A high voltage surge protection device.*/ kIfcProtectiveDeviceTypeEnum_VARISTOR, /** a voltage limiter is an equipment that prevents the over voltage.*/ kIfcProtectiveDeviceTypeEnum_VOLTAGELIMITER, /** User-defined type.*/ kIfcProtectiveDeviceTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcProtectiveDeviceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcProtectiveDeviceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcProtectiveDeviceTypeEnum& getUnset() { static OdIfc4x4::IfcProtectiveDeviceTypeEnum nullEnum = OdIfc4x4::kIfcProtectiveDeviceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcPumpTypeEnum& getUnset() { static OdIfc4x4::IfcPumpTypeEnum nullEnum = OdIfc4x4::kIfcPumpTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { enum IfcRadialExcavationTypeEnum { kIfcRadialExcavationTypeEnum_NICHE, kIfcRadialExcavationTypeEnum_PROFILEENLARGEMENT, kIfcRadialExcavationTypeEnum_REPROFILING, kIfcRadialExcavationTypeEnum_USERDEFINED, kIfcRadialExcavationTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcRadialExcavationTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcRadialExcavationTypeEnum& getUnset() { static OdIfc4x4::IfcRadialExcavationTypeEnum nullEnum = OdIfc4x4::kIfcRadialExcavationTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration defines the different predefined types of an IfcRail or IfcRailType object. */ enum IfcRailTypeEnum { /** A blade is a machined rail, often of special section, but fixed and/or joined at the heel end to a rail to provide continuity of wheel support. The two switch rails in a set are the two inside rails. A switch rail is described as right or left hand according to whether it is part of a right hand or left hand half-set of switches.*/ kIfcRailTypeEnum_BLADE, /** A check rail is a rail laid close to the gauge face of a running rail which takes part in lateral guidance of the wheel and prevents derailment in small radius curved track and switches and crossings.*/ kIfcRailTypeEnum_CHECKRAIL, /** A guard rail is a rail that limits risk of train derailment, normally not loaded.*/ kIfcRailTypeEnum_GUARDRAIL, /** A rack rail is a building module for enhancing traction and break performance.*/ kIfcRailTypeEnum_RACKRAIL, /** A rail is a special section bar (usually of steel) ensuring the guidance of the wheel of a rolling stock or other heavy machineries. In railway, two rails are combined to form a track.*/ kIfcRailTypeEnum_RAIL, /** A stock rail is a fixed machined rail, ensuring the continuity on the main or diverging track with the switch in the open position. The machined part of the stock rail supports its switch rail in the closed position, giving continuity of line through this switch rail. The two stock rails in a set of switches are the two outside rails. A stock rail is described as right or left hand according to whether it is part of a right hand or left hand half-set of switches.*/ kIfcRailTypeEnum_STOCKRAIL, /** User-defined type*/ kIfcRailTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcRailTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcRailTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcRailTypeEnum& getUnset() { static OdIfc4x4::IfcRailTypeEnum nullEnum = OdIfc4x4::kIfcRailTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration defines the different types of IfcRailing or IfcRailingType that can be predefined using the enumeration values. */ enum IfcRailingTypeEnum { /** 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, /** NOTE Definition from ISO6707-1: non-load bearing vertical construction, usually lightweight, which bounds or subdivides an external area.*/ kIfcRailingTypeEnum_FENCE, /** 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, /** 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, /** 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 OdIfc4x4::IfcRailingTypeEnum& getUnset() { static OdIfc4x4::IfcRailingTypeEnum nullEnum = OdIfc4x4::kIfcRailingTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details The IfcRailwayPartTypeEnum defines the range of different types of railway part that can be specified. */ enum IfcRailwayPartTypeEnum { /** A spatial structure element that contains elements that are positioned above or over the track, for example catenary lines and suspension systems.*/ kIfcRailwayPartTypeEnum_ABOVETRACK, /** No description available.*/ kIfcRailwayPartTypeEnum_DILATIONTRACK, /** A spatial structure element that contains elements of the railway that are not in or over the tracks, hence line-side.*/ kIfcRailwayPartTypeEnum_LINESIDE, /** A spatial structure element to further divide a line-side part. It can be used to distinguish line-side parts into more manageable volumes, for engineering purposes.*/ kIfcRailwayPartTypeEnum_LINESIDEPART, /** A spatial structure element to further divide a track. It does do not contain any turnout panel or dilatation panel.*/ kIfcRailwayPartTypeEnum_PLAINTRACK, /** A spatial structure element that contains elements that are positioned below the track, for example the earthwork platform, prepared subgrade and embankment. This can be above or below finished ground level.*/ kIfcRailwayPartTypeEnum_SUBSTRUCTURE, /** A spatial structure element that contains track-related elements, for example rails and sleepers.*/ kIfcRailwayPartTypeEnum_TRACK, /** A spatial structure element to further divide a track, for purposes that do not fall into these categories: plain-track, turnout-track, dilatation-track.*/ kIfcRailwayPartTypeEnum_TRACKPART, /** A spatial structure element to further divide a track. It contains turnouts, and does not contain any plain track or dilatation panel.*/ kIfcRailwayPartTypeEnum_TURNOUTTRACK, /** User-defined type*/ kIfcRailwayPartTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcRailwayPartTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcRailwayPartTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcRailwayPartTypeEnum& getUnset() { static OdIfc4x4::IfcRailwayPartTypeEnum nullEnum = OdIfc4x4::kIfcRailwayPartTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details Types of railways. */ enum IfcRailwayTypeEnum { /** User-defined type.*/ kIfcRailwayTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcRailwayTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcRailwayTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcRailwayTypeEnum& getUnset() { static OdIfc4x4::IfcRailwayTypeEnum nullEnum = OdIfc4x4::kIfcRailwayTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration defines the different types an IfcRampFlight or IfcRampFlightType object can fulfill. */ enum IfcRampFlightTypeEnum { /** A ramp flight with a circular or elliptic walking line.*/ kIfcRampFlightTypeEnum_SPIRAL, /** A ramp flight with a straight walking line.*/ kIfcRampFlightTypeEnum_STRAIGHT, /** User-defined ramp flight.*/ kIfcRampFlightTypeEnum_USERDEFINED, /** Undefined ramp flight.*/ kIfcRampFlightTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcRampFlightTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcRampFlightTypeEnum& getUnset() { static OdIfc4x4::IfcRampFlightTypeEnum nullEnum = OdIfc4x4::kIfcRampFlightTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 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 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 constructed around a circular or elliptical well without newels and landings.*/ kIfcRampTypeEnum_SPIRAL_RAMP, /** 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 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 straight ramp consisting of two straight flights without turns but with one landing.*/ kIfcRampTypeEnum_TWO_STRAIGHT_RUN_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 OdIfc4x4::IfcRampTypeEnum& getUnset() { static OdIfc4x4::IfcRampTypeEnum nullEnum = OdIfc4x4::kIfcRampTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details IfcRecurrenceTypeEnum enumerates the recurring pattern type, with valid combinations as indicated. */ enum IfcRecurrenceTypeEnum { /** Interval, Occurrences*/ kIfcRecurrenceTypeEnum_BY_DAY_COUNT, /** WeekdayComponent, Interval, Occurrences*/ kIfcRecurrenceTypeEnum_BY_WEEKDAY_COUNT, /** Interval, Occurrences*/ kIfcRecurrenceTypeEnum_DAILY, /** DayComponent, Interval, Occurrences*/ kIfcRecurrenceTypeEnum_MONTHLY_BY_DAY_OF_MONTH, /** WeekdayComponent, Position, Interval, Occurrences*/ kIfcRecurrenceTypeEnum_MONTHLY_BY_POSITION, /** WeekdayComponent, Interval, Occurrences*/ kIfcRecurrenceTypeEnum_WEEKLY, /** 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 OdIfc4x4::IfcRecurrenceTypeEnum& getUnset() { static OdIfc4x4::IfcRecurrenceTypeEnum nullEnum = OdIfc4x4::kIfcRecurrenceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration defines the different types of referents. */ enum IfcReferentTypeEnum { /** The referent represents where an administrative or maintenance boundary crosses the linear element being measured. This is typically the first time the boundary crosses the linear element. If the boundary runs along the linear element, it would be the point at which they first become collinear. The LRS (linear referencing system) should include specific rules about how boundaries are handled if this type of referent is permitted. If the linear element changes at the boundary as for a county route beginning at the county boundary, then the LRM (linear referencing method) is more correctly categorized as absolute.*/ kIfcReferentTypeEnum_BOUNDARY, /** The referent is the location of an intersection specified by the referent name. The intersection location is typically taken as the location of the intersection of the reference lines of the streets comprising the intersection and is, therefore, not necessarily precise or deterministic. Physical markers can be installed to remedy this. The LRS (linear referencing system) should include specific rules about how intersection locations are determined if this type of referent is permitted.*/ kIfcReferentTypeEnum_INTERSECTION, /** Kilo point*/ kIfcReferentTypeEnum_KILOPOINT, /** The referent is the location of a physical landmark visible in the field.*/ kIfcReferentTypeEnum_LANDMARK, /** Mile point*/ kIfcReferentTypeEnum_MILEPOINT, /** Used to fully describe a linearly referenced location given by the linear element being measured (the IfcAlignment into which the IfcReferent is nested), the method of measurement (Pset_LinearReferencingMethod) and a measure value (Pset_Stationing). If a linear referencing method is specified for the position, it overrides any linear referencing method specified for the alignment.*/ kIfcReferentTypeEnum_POSITION, /** The reference marker is a notation referent, typically located in the right of way of the road, rail or other transportation system. Usually reference markers are initially spaced at a uniform distance along the linear element being measured, though subsequent re-alignments can result in uneven spacing between the markers.*/ kIfcReferentTypeEnum_REFERENCEMARKER, /** Station*/ kIfcReferentTypeEnum_STATION, /** A kind of event that specifies the superelevation (cross slope) at a specific location along a road alignment, and the type of transition from the previous location. The locations are specified using an IfcLinearPlacement measured along the alignment axis curve. The element(s) that are affected by the superelevation event is currently proposed to be specified by containing the event in a specific lateral breakdown element of the road spatial structure (e.g. a Lane).*/ kIfcReferentTypeEnum_SUPERELEVATIONEVENT, /** A kind of event that specifies the width at a specific location along a road alignment, and the type of transition from the previous location. The locations are specified using an IfcLinearPlacement measured along the alignment axis curve. The element(s) that are affected by the width event is currently proposed to be specified by containing the event in a specific lateral breakdown element of the road spatial structure (e.g. a Lane or the entire carriageway).*/ kIfcReferentTypeEnum_WIDTHEVENT, /** User defined.*/ kIfcReferentTypeEnum_USERDEFINED, /** Undefined.*/ kIfcReferentTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcReferentTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcReferentTypeEnum& getUnset() { static OdIfc4x4::IfcReferentTypeEnum nullEnum = OdIfc4x4::kIfcReferentTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 conforming with the Physical lighting model defined in X3D.*/ kIfcReflectanceMethodEnum_PHYSICAL, /** 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 OdIfc4x4::IfcReflectanceMethodEnum& getUnset() { static OdIfc4x4::IfcReflectanceMethodEnum nullEnum = OdIfc4x4::kIfcReflectanceMethodEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This container defines the different predefined types of soil reinforcement that can specify an IfcReinforcedSoil. */ enum IfcReinforcedSoilTypeEnum { /** The method of using dynamic tamping machine usually free falling a heavy hammer from the height, compacting the soil and quickly improving the bearing capacity of the foundation.*/ kIfcReinforcedSoilTypeEnum_DYNAMICALLYCOMPACTED, /** A method of injecting curable slurry into cracks or pores of a geotechnical foundation to improve its physical and mechanical properties.*/ kIfcReinforcedSoilTypeEnum_GROUTED, /** Dig out the soft soil in a certain range below the foundation ground and then backfill the area with high strength, low compressibility and no corrosive materials.*/ kIfcReinforcedSoilTypeEnum_REPLACED, /** A kind of compacting method that adopts rolling machinery, repeated rolling and vibration compacts the foundation soil, increasing strength and descreasing compressibility.*/ kIfcReinforcedSoilTypeEnum_ROLLERCOMPACTED, /** A method that applies load to the foundation to discharge pore water, and the foundation is consolidated to improve the foundation strength. Unloading when the carrying capacity reaches the required level.*/ kIfcReinforcedSoilTypeEnum_SURCHARGEPRELOADED, /** A method to set vertical drainage measures in the foundation, so that pore water in the soil is discharged and the foundation strength is improved.*/ kIfcReinforcedSoilTypeEnum_VERTICALLYDRAINED, /** User-defined type*/ kIfcReinforcedSoilTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcReinforcedSoilTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcReinforcedSoilTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcReinforcedSoilTypeEnum& getUnset() { static OdIfc4x4::IfcReinforcedSoilTypeEnum nullEnum = OdIfc4x4::kIfcReinforcedSoilTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 { /** Anchoring reinforcement.*/ kIfcReinforcingBarRoleEnum_ANCHORING, /** Edge reinforcement.*/ kIfcReinforcingBarRoleEnum_EDGE, /** The reinforcing bar is a ligature (link, stirrup).*/ kIfcReinforcingBarRoleEnum_LIGATURE, /** The reinforcing bar is a main bar.*/ kIfcReinforcingBarRoleEnum_MAIN, /** Punching reinforcement.*/ kIfcReinforcingBarRoleEnum_PUNCHING, /** Ring reinforcement.*/ kIfcReinforcingBarRoleEnum_RING, /** The reinforcing bar is a shear bar.*/ kIfcReinforcingBarRoleEnum_SHEAR, /** The reinforcing bar is a stud.*/ kIfcReinforcingBarRoleEnum_STUD, /** 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 OdIfc4x4::IfcReinforcingBarRoleEnum& getUnset() { static OdIfc4x4::IfcReinforcingBarRoleEnum nullEnum = OdIfc4x4::kIfcReinforcingBarRoleEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcReinforcingBarSurfaceEnum& getUnset() { static OdIfc4x4::IfcReinforcingBarSurfaceEnum nullEnum = OdIfc4x4::kIfcReinforcingBarSurfaceEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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, /** A stirrup in pre-stressing system to position TendonConduit.*/ kIfcReinforcingBarTypeEnum_SPACEBAR, /** The reinforcing bar is a stud.*/ kIfcReinforcingBarTypeEnum_STUD, /** 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 OdIfc4x4::IfcReinforcingBarTypeEnum& getUnset() { static OdIfc4x4::IfcReinforcingBarTypeEnum nullEnum = OdIfc4x4::kIfcReinforcingBarTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details Enumeration defining the reinforcing mesh type. */ enum IfcReinforcingMeshTypeEnum { kIfcReinforcingMeshTypeEnum_STEELSTRAPS, /** 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 OdIfc4x4::IfcReinforcingMeshTypeEnum& getUnset() { static OdIfc4x4::IfcReinforcingMeshTypeEnum nullEnum = OdIfc4x4::kIfcReinforcingMeshTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details The predefined type container that collects all possible road facility part types together into the implemented enumeration. */ enum IfcRoadPartTypeEnum { /** Designated level crossing over a road for cyclists.*/ kIfcRoadPartTypeEnum_BICYCLECROSSING, /** Lateral part of Road for stopping buses allowing them to draw out of the traffic lanes and wait for short periods.*/ kIfcRoadPartTypeEnum_BUS_STOP, /** Unitary lateral part of Road built for traffic. Carriageway may comprise several kinds of traffic lanes and lay-bys, as well as traffic islands, and in case of dual carriageway road they are separated by central reserve.*/ kIfcRoadPartTypeEnum_CARRIAGEWAY, /** The center of a roundabout not intended for traffic, can be painted or upraised.*/ kIfcRoadPartTypeEnum_CENTRALISLAND, /** Lateral RoadPart separating two carriageways of the same road or separating traffic lanes and sidewalk.*/ kIfcRoadPartTypeEnum_CENTRALRESERVE, /** A type of Shoulder that is surfaced, providing for safe use by vehicles in distress.*/ kIfcRoadPartTypeEnum_HARDSHOULDER, /** At-grade junction where two or more roads meet or cross. Intersections may be further classified by number of road segments, traffic controls, and/or lane design.*/ kIfcRoadPartTypeEnum_INTERSECTION, /** A lateral part of Road where vehicles can divert from ordinary stream of traffic.*/ kIfcRoadPartTypeEnum_LAYBY, /** Lateral part of Road for parking vehicles.*/ kIfcRoadPartTypeEnum_PARKINGBAY, /** A lateral part of Road that is a widening of an otherwise single lane road where a vehicle may move over to enable another vehicle to pass.*/ kIfcRoadPartTypeEnum_PASSINGBAY, /** Designated level crossing over a road for pedestrians.*/ kIfcRoadPartTypeEnum_PEDESTRIAN_CROSSING, /** At-grade crossing between road and railway.*/ kIfcRoadPartTypeEnum_RAILWAYCROSSING, /** A raised platform or a guarded area so sited in the carriageway as to divide the streams of traffic and to provide a safety area for pedestrians.*/ kIfcRoadPartTypeEnum_REFUGEISLAND, /** Longitudinal, linear segment of a road, either defined by uniform characteristics, or as a transition segment (e.g. number of lanes changing).*/ kIfcRoadPartTypeEnum_ROADSEGMENT, /** A lateral RoadPart located along the Road adjoining the outer edges of the Shoulders. A general concept comprising the areas outside RoadwayPlateau not intended for vehicles.*/ kIfcRoadPartTypeEnum_ROADSIDE, /** A general concept for various parts of the Roadside.*/ kIfcRoadPartTypeEnum_ROADSIDEPART, /** Lateral part of Road comprising the carriageway(s), shoulders and medians.*/ kIfcRoadPartTypeEnum_ROADWAYPLATEAU, /** Type of at-grade junction at which traffic streams are directed around a circle.*/ kIfcRoadPartTypeEnum_ROUNDABOUT, /** A lateral part of Road adjacent to, and usually at the same level as the Carriageway; not intended for vehicular traffic but may be used in case of emergency.*/ kIfcRoadPartTypeEnum_SHOULDER, /** A footpath along the side of a road. May accommodate moderate changes in grade (elevation) and is normally separated from the vehicular section by a kerb. There may be a central reserve or road verge between the sidewalk and traffic lanes.*/ kIfcRoadPartTypeEnum_SIDEWALK, /** A type of Shoulder that is not surfaced.*/ kIfcRoadPartTypeEnum_SOFTSHOULDER, /** A part of road facility where tolls are collected for use of toll road, tunnel or bridge.*/ kIfcRoadPartTypeEnum_TOLLPLAZA, /** A central or subsidiary area raised or marked on the carriageway, generally at a road junction or level crossing, shaped and placed so as to direct traffic movement and/or provide refuge for pedestrians.*/ kIfcRoadPartTypeEnum_TRAFFICISLAND, /** Lateral part of carriageway designated to vehicular traffic for a particular purpose.*/ kIfcRoadPartTypeEnum_TRAFFICLANE, /** User-defined type*/ kIfcRoadPartTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcRoadPartTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcRoadPartTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcRoadPartTypeEnum& getUnset() { static OdIfc4x4::IfcRoadPartTypeEnum nullEnum = OdIfc4x4::kIfcRoadPartTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details The predefined type container that collects all possible road facility types together into the implemented enumeration. */ enum IfcRoadTypeEnum { /** User-defined type.*/ kIfcRoadTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcRoadTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcRoadTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcRoadTypeEnum& getUnset() { static OdIfc4x4::IfcRoadTypeEnum nullEnum = OdIfc4x4::kIfcRoadTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration defines roles which may be played by an actor. */ enum IfcRoleEnum { /** Architect*/ kIfcRoleEnum_ARCHITECT, /** Facility operator*/ kIfcRoleEnum_BUILDINGOPERATOR, /** Facility owner*/ kIfcRoleEnum_BUILDINGOWNER, /** Civil engineer*/ kIfcRoleEnum_CIVILENGINEER, /** Client*/ kIfcRoleEnum_CLIENT, /** Commissioning engineer*/ kIfcRoleEnum_COMMISSIONINGENGINEER, /** Construction manager*/ kIfcRoleEnum_CONSTRUCTIONMANAGER, /** Consultant*/ kIfcRoleEnum_CONSULTANT, /** Contractor*/ kIfcRoleEnum_CONTRACTOR, /** Cost engineer*/ kIfcRoleEnum_COSTENGINEER, /** Electrical engineer*/ kIfcRoleEnum_ELECTRICALENGINEER, /** Engineer*/ kIfcRoleEnum_ENGINEER, /** Facilities manager*/ kIfcRoleEnum_FACILITIESMANAGER, /** Field construction manager*/ kIfcRoleEnum_FIELDCONSTRUCTIONMANAGER, /** Manufacturer*/ kIfcRoleEnum_MANUFACTURER, /** Mechanical engineer*/ kIfcRoleEnum_MECHANICALENGINEER, /** Owner*/ kIfcRoleEnum_OWNER, /** Project manager*/ kIfcRoleEnum_PROJECTMANAGER, /** Reseller*/ kIfcRoleEnum_RESELLER, /** Structural engineer*/ kIfcRoleEnum_STRUCTURALENGINEER, /** Sub-contractor*/ kIfcRoleEnum_SUBCONTRACTOR, /** Supplier*/ kIfcRoleEnum_SUPPLIER, /** User defined value to be provided.*/ kIfcRoleEnum_USERDEFINED, /** The value is unset.*/ kIfcRoleEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcRoleEnum& getUnset() { static OdIfc4x4::IfcRoleEnum nullEnum = OdIfc4x4::kIfcRoleEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration defines the basic configuration of the roof in terms of the different roof shapes. */ enum IfcRoofTypeEnum { /** A roof or ceiling having a semicylindrical form.*/ kIfcRoofTypeEnum_BARREL_ROOF, /** A roof having two slopes, each descending inward from the eaves.*/ kIfcRoofTypeEnum_BUTTERFLY_ROOF, /** A hemispherical hip roof.*/ kIfcRoofTypeEnum_DOME_ROOF, /** A roof having no slope, or one with only a slight pitch so as to drain rainwater.*/ kIfcRoofTypeEnum_FLAT_ROOF, /** Free form roof.*/ kIfcRoofTypeEnum_FREEFORM, /** 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 sloping downward in two parts from a central ridge, so as to form a gable at each end.*/ kIfcRoofTypeEnum_GAMBREL_ROOF, /** A roof having a hipped end truncating a gable.*/ kIfcRoofTypeEnum_HIPPED_GABLE_ROOF, /** A roof having sloping ends and sides meeting at an inclined projecting angle.*/ kIfcRoofTypeEnum_HIP_ROOF, /** A roof having on each side a steeper lower part and a shallower upper part.*/ kIfcRoofTypeEnum_MANSARD_ROOF, /** A pyramidal hip roof.*/ kIfcRoofTypeEnum_PAVILION_ROOF, /** A gable roof in the form of a broad Gothic arch, with gently sloping convex surfaces.*/ kIfcRoofTypeEnum_RAINBOW_ROOF, /** A roof having a single slope.*/ kIfcRoofTypeEnum_SHED_ROOF, /** No specification given.*/ kIfcRoofTypeEnum_USERDEFINED, /** No specification given.*/ kIfcRoofTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcRoofTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcRoofTypeEnum& getUnset() { static OdIfc4x4::IfcRoofTypeEnum nullEnum = OdIfc4x4::kIfcRoofTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details [object Object] */ enum IfcSIPrefix { /** 10^-18.*/ kIfcSIPrefix_ATTO, /** 10^-2.*/ kIfcSIPrefix_CENTI, /** 10.*/ kIfcSIPrefix_DECA, /** 10^-1.*/ kIfcSIPrefix_DECI, /** 10^18.*/ kIfcSIPrefix_EXA, /** 10^-15.*/ kIfcSIPrefix_FEMTO, /** 10^9.*/ kIfcSIPrefix_GIGA, /** 10^2.*/ kIfcSIPrefix_HECTO, /** 10^3.*/ kIfcSIPrefix_KILO, /** 10^6.*/ kIfcSIPrefix_MEGA, /** 10^-6.*/ kIfcSIPrefix_MICRO, /** 10^-3.*/ kIfcSIPrefix_MILLI, /** 10^-9.*/ kIfcSIPrefix_NANO, /** 10^15.*/ kIfcSIPrefix_PETA, /** 10^-12.*/ kIfcSIPrefix_PICO, /** 10^12.*/ kIfcSIPrefix_TERA, /** The value is unset.*/ kIfcSIPrefix_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcSIPrefix& getUnset() { static OdIfc4x4::IfcSIPrefix nullEnum = OdIfc4x4::kIfcSIPrefix_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcSIUnitName& getUnset() { static OdIfc4x4::IfcSIUnitName nullEnum = OdIfc4x4::kIfcSIUnitName_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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, /** A sanitary terminal that provides a low pressure jet of water for a specific purpose.*/ kIfcSanitaryTerminalTypeEnum_SANITARYFOUNTAIN, /** 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, /** 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 OdIfc4x4::IfcSanitaryTerminalTypeEnum& getUnset() { static OdIfc4x4::IfcSanitaryTerminalTypeEnum nullEnum = OdIfc4x4::kIfcSanitaryTerminalTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details An enumeration indicating whether a specific piece of a cross section is uniform or tapered in longitudinal direction. */ enum IfcSectionTypeEnum { /** The section is tapered in longitudinal direction.*/ kIfcSectionTypeEnum_TAPERED, /** The section is uniform in longitudinal direction.*/ kIfcSectionTypeEnum_UNIFORM, /** The value is unset.*/ kIfcSectionTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcSectionTypeEnum& getUnset() { static OdIfc4x4::IfcSectionTypeEnum nullEnum = OdIfc4x4::kIfcSectionTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details The IfcSensorTypeEnum defines the range of different types of sensor that can be specified. */ enum IfcSensorTypeEnum { /** A device that senses or detects carbon dioxide.*/ kIfcSensorTypeEnum_CO2SENSOR, /** A device that senses or detects 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 carbon monoxide.*/ kIfcSensorTypeEnum_COSENSOR, /** A device that senses or detects the seismic wave and measures the seismic intensity in case of earthquake.*/ kIfcSensorTypeEnum_EARTHQUAKESENSOR, /** 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 foreign objects that shock or break the power network. It may alarm when such accidents happen.*/ kIfcSensorTypeEnum_FOREIGNOBJECTDETECTIONSENSOR, /** 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 any obstacles. Examples are: detectors sensing objects falling from a bridge, rock-fall detectors, etc.*/ kIfcSensorTypeEnum_OBSTACLESENSOR, /** 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 collects rainfall related information.*/ kIfcSensorTypeEnum_RAINSENSOR, /** A device that senses or detects smoke.*/ kIfcSensorTypeEnum_SMOKESENSOR, /** A device that senses or measures the depth of snowfall.*/ kIfcSensorTypeEnum_SNOWDEPTHSENSOR, /** A device that senses or detects sound.*/ kIfcSensorTypeEnum_SOUNDSENSOR, /** A device that senses or detects temperature.*/ kIfcSensorTypeEnum_TEMPERATURESENSOR, /** A device, usually attached to the rear end of the last vehicle of a train, acting on a fixed equipment to give an indication that the train is complete.*/ kIfcSensorTypeEnum_TRAINSENSOR, /** A device that senses or detects the position of a blade of a turnout.*/ kIfcSensorTypeEnum_TURNOUTCLOSURESENSOR, /** A device that senses or detects the passage of a wheel.*/ kIfcSensorTypeEnum_WHEELSENSOR, /** 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 OdIfc4x4::IfcSensorTypeEnum& getUnset() { static OdIfc4x4::IfcSensorTypeEnum nullEnum = OdIfc4x4::kIfcSensorTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 finish before the successor task may finish.*/ kIfcSequenceEnum_FINISH_FINISH, /** The predecessor task must finish before the successor task may start.*/ kIfcSequenceEnum_FINISH_START, /** The predecessor task must start before the successor task may finish.*/ kIfcSequenceEnum_START_FINISH, /** The predecessor task must start before the successor task may start.*/ kIfcSequenceEnum_START_START, /** User defined.*/ kIfcSequenceEnum_USERDEFINED, /** Undefined.*/ kIfcSequenceEnum_NOTDEFINED, /** The value is unset.*/ kIfcSequenceEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcSequenceEnum& getUnset() { static OdIfc4x4::IfcSequenceEnum nullEnum = OdIfc4x4::kIfcSequenceEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration defines the valid types of IfcShadingDevice or IfcShadingDeviceType that can be predefined using the enumeration values. */ enum IfcShadingDeviceTypeEnum { /** 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, /** 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, /** No description available.*/ kIfcShadingDeviceTypeEnum_USERDEFINED, /** No description available.*/ kIfcShadingDeviceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcShadingDeviceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcShadingDeviceTypeEnum& getUnset() { static OdIfc4x4::IfcShadingDeviceTypeEnum nullEnum = OdIfc4x4::kIfcShadingDeviceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This container defines the different predefined types of signs that can specify an IfcSign or IfcSignType. */ enum IfcSignTypeEnum { /** A Sign type formed of a vertical post (possibly with some lettering or symbols) usually used to delimitate distance or the location of some equipment.*/ kIfcSignTypeEnum_MARKER, /** A sign type that provides information via a reflective mirror surface.*/ kIfcSignTypeEnum_MIRROR, /** A sign type formed of a flat plate with some written or symbolic images on it.*/ kIfcSignTypeEnum_PICTORAL, /** User-defined type*/ kIfcSignTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcSignTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcSignTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcSignTypeEnum& getUnset() { static OdIfc4x4::IfcSignTypeEnum nullEnum = OdIfc4x4::kIfcSignTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This container defines the different predefined types of signals that can specify an IfcSignal or IfcSignalType. */ enum IfcSignalTypeEnum { /** A signal type formed of an active device conveying information by emitting an audio signal such as a beep, ring, horn or explosive sound.*/ kIfcSignalTypeEnum_AUDIO, /** A signal type formed of an active device conveying information in both a visual and audio manner.*/ kIfcSignalTypeEnum_MIXED, /** A signal type formed of an active device conveying information in a visual manner such as a light, cluster of lights, or mechanical moving shapes.*/ kIfcSignalTypeEnum_VISUAL, /** User-defined type*/ kIfcSignalTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcSignalTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcSignalTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcSignalTypeEnum& getUnset() { static OdIfc4x4::IfcSignalTypeEnum nullEnum = OdIfc4x4::kIfcSignalTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 IfcPropertyBoundedValue.*/ kIfcSimplePropertyTemplateTypeEnum_P_BOUNDEDVALUE, /** The properties defined by this IfcPropertyTemplate are of type IfcPropertyEnumeratedValue.*/ kIfcSimplePropertyTemplateTypeEnum_P_ENUMERATEDVALUE, /** The properties defined by this IfcPropertyTemplate are of type IfcPropertyListValue.*/ kIfcSimplePropertyTemplateTypeEnum_P_LISTVALUE, /** The properties defined by this IfcPropertyTemplate are of type IfcPropertyReferenceValue.*/ kIfcSimplePropertyTemplateTypeEnum_P_REFERENCEVALUE, /** The properties defined by this IfcPropertyTemplate are of type IfcPropertySingleValue.*/ kIfcSimplePropertyTemplateTypeEnum_P_SINGLEVALUE, /** The properties defined by this IfcPropertyTemplate are of type IfcPropertyTableValue.*/ kIfcSimplePropertyTemplateTypeEnum_P_TABLEVALUE, /** The properties defined by this IfcPropertyTemplate are of type IfcQuantityArea.*/ kIfcSimplePropertyTemplateTypeEnum_Q_AREA, /** The properties defined by this IfcPropertyTemplate are of type IfcQuantityCount.*/ kIfcSimplePropertyTemplateTypeEnum_Q_COUNT, /** The properties defined by this IfcPropertyTemplate are of type IfcQuantityLength.*/ kIfcSimplePropertyTemplateTypeEnum_Q_LENGTH, /** No description available.*/ kIfcSimplePropertyTemplateTypeEnum_Q_NUMBER, /** The properties defined by this IfcPropertyTemplate are of type IfcQuantityNumber.*/ kIfcSimplePropertyTemplateTypeEnum_Q_TIME, /** The properties defined by this IfcPropertyTemplate are of type IfcQuantityVolume.*/ kIfcSimplePropertyTemplateTypeEnum_Q_VOLUME, /** The properties defined by this IfcPropertyTemplate are of type IfcQuantityWeight.*/ kIfcSimplePropertyTemplateTypeEnum_Q_WEIGHT, /** The value is unset.*/ kIfcSimplePropertyTemplateTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcSimplePropertyTemplateTypeEnum& getUnset() { static OdIfc4x4::IfcSimplePropertyTemplateTypeEnum nullEnum = OdIfc4x4::kIfcSimplePropertyTemplateTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration defines the available predefined types of slabs that can further specify an IfcSlab or IfcSlabType. */ enum IfcSlabTypeEnum { /** Iis part of bridge abutment providing transition from embankment to the bridge*/ kIfcSlabTypeEnum_APPROACH_SLAB, /** 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, /** The slab is used to represent a floor slab or a bridge deck.*/ kIfcSlabTypeEnum_FLOOR, /** The slab is used to represent a landing within a stair or ramp.*/ kIfcSlabTypeEnum_LANDING, /** Rigid pavement course of a road or other paved area, usually concrete.*/ kIfcSlabTypeEnum_PAVING, /** The slab is used to represent a roof slab (either flat or sloped).*/ kIfcSlabTypeEnum_ROOF, /** The slab is used to represent a sidewalk.*/ kIfcSlabTypeEnum_SIDEWALK, /** A track slab is a reinforced concrete slab or prestressed reinforced concrete slab, which is a main element of slab track. It can be prefabricated or cast on site and may have sleepers embedded.*/ kIfcSlabTypeEnum_TRACKSLAB, /** The slab is used to represent a wearing surface.*/ kIfcSlabTypeEnum_WEARING, /** No description available.*/ kIfcSlabTypeEnum_USERDEFINED, /** No description available.*/ kIfcSlabTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcSlabTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcSlabTypeEnum& getUnset() { static OdIfc4x4::IfcSlabTypeEnum nullEnum = OdIfc4x4::kIfcSlabTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcSolarDeviceTypeEnum& getUnset() { static OdIfc4x4::IfcSolarDeviceTypeEnum nullEnum = OdIfc4x4::kIfcSolarDeviceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcSpaceHeaterTypeEnum& getUnset() { static OdIfc4x4::IfcSpaceHeaterTypeEnum nullEnum = OdIfc4x4::kIfcSpaceHeaterTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration defines the available generic types for IfcSpace and IfcSpaceType. */ enum IfcSpaceTypeEnum { /** A space dedicated to the berthing of vessels within a port or managed area*/ kIfcSpaceTypeEnum_BERTH, /** A space outside of a facility.*/ kIfcSpaceTypeEnum_EXTERNAL, /** 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 dedication for use as a parking spot for vehicles, including access, such as a parking aisle.*/ kIfcSpaceTypeEnum_PARKING, /** Any space not falling into another category.*/ kIfcSpaceTypeEnum_SPACE, /** No description available.*/ kIfcSpaceTypeEnum_USERDEFINED, /** No description available.*/ kIfcSpaceTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcSpaceTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcSpaceTypeEnum& getUnset() { static OdIfc4x4::IfcSpaceTypeEnum nullEnum = OdIfc4x4::kIfcSpaceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration defines the range of different types of spatial zones that can further specify an IfcSpatialZone. */ enum IfcSpatialZoneTypeEnum { kIfcSpatialZoneTypeEnum_ANNULARGAP, kIfcSpatialZoneTypeEnum_CLEARANCE, kIfcSpatialZoneTypeEnum_COMPARTMENT, /** 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, kIfcSpatialZoneTypeEnum_INSTALLATION, /** The spatial zone is used to define an interference between IfcSpatialElement occurrences.*/ kIfcSpatialZoneTypeEnum_INTERFERENCE, kIfcSpatialZoneTypeEnum_INTERIOR, kIfcSpatialZoneTypeEnum_INVERT, /** The spatial zone is used to represent a lighting zone; a daylight zone, or an artificial lighting zone.*/ kIfcSpatialZoneTypeEnum_LIGHTING, kIfcSpatialZoneTypeEnum_LINING, kIfcSpatialZoneTypeEnum_MAPPEDZONE, /** The spatial zone is used to represent a zone of particular occupancy.*/ kIfcSpatialZoneTypeEnum_OCCUPANCY, /** A spatial zone that marks some sort of reservation within the project extent.*/ kIfcSpatialZoneTypeEnum_RESERVATION, /** The spatial zone is used to represent a zone for security planning and maintenance work.*/ kIfcSpatialZoneTypeEnum_SECURITY, kIfcSpatialZoneTypeEnum_SERVICE, kIfcSpatialZoneTypeEnum_TESTEDZONE, /** 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 OdIfc4x4::IfcSpatialZoneTypeEnum& getUnset() { static OdIfc4x4::IfcSpatialZoneTypeEnum nullEnum = OdIfc4x4::kIfcSpatialZoneTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcStackTerminalTypeEnum& getUnset() { static OdIfc4x4::IfcStackTerminalTypeEnum nullEnum = OdIfc4x4::kIfcStackTerminalTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 curved walking line.*/ kIfcStairFlightTypeEnum_CURVED, /** A stair flight with a free form walking line (and outer boundaries).*/ kIfcStairFlightTypeEnum_FREEFORM, /** A stair flight with a circular or elliptic walking line.*/ kIfcStairFlightTypeEnum_SPIRAL, /** A stair flight with a straight walking line.*/ kIfcStairFlightTypeEnum_STRAIGHT, /** A stair flight with a walking line including straight and curved sections.*/ kIfcStairFlightTypeEnum_WINDER, /** User-defined stair flight.*/ kIfcStairFlightTypeEnum_USERDEFINED, /** Undefined stair flight.*/ kIfcStairFlightTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcStairFlightTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcStairFlightTypeEnum& getUnset() { static OdIfc4x4::IfcStairFlightTypeEnum nullEnum = OdIfc4x4::kIfcStairFlightTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 is consisting of one curved flight.*/ kIfcStairTypeEnum_CURVED_RUN_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 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 one half winder, which makes a 180° turn. The orientation of the turn is determined by the walking line.*/ kIfcStairTypeEnum_HALF_WINDING_STAIR, /** a piece of equipment consisting of a series of bars or steps between two upright elements used for climbing up or down something*/ kIfcStairTypeEnum_LADDER, /** 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 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 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 extending from one level to another without turns or winders. The stair consists of one straight flight.*/ kIfcStairTypeEnum_STRAIGHT_RUN_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 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 curved stair consisting of two curved flights without turns but with one landing.*/ kIfcStairTypeEnum_TWO_CURVED_RUN_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 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 straight stair consisting of two straight flights without turns but with one landing.*/ kIfcStairTypeEnum_TWO_STRAIGHT_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 OdIfc4x4::IfcStairTypeEnum& getUnset() { static OdIfc4x4::IfcStairTypeEnum nullEnum = OdIfc4x4::kIfcStairTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details The IfcStateEnum enumeration identifies the state or accessibility of the object (for example, read/write, locked). */ enum IfcStateEnum { /** Object is in a Locked state. It may not be accessed by an application.*/ kIfcStateEnum_LOCKED, /** Object is in a Read-Only state. It may be viewed but not modified by an application.*/ kIfcStateEnum_READONLY, /** Object is in a Read-Only-Locked state. It may not be accessed by an application.*/ kIfcStateEnum_READONLYLOCKED, /** Object is in a Read-Write state. It may be modified by an application.*/ kIfcStateEnum_READWRITE, /** Object is in a Read-Write-Locked state. It may not be accessed by an application.*/ kIfcStateEnum_READWRITELOCKED, /** The value is unset.*/ kIfcStateEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcStateEnum& getUnset() { static OdIfc4x4::IfcStateEnum nullEnum = OdIfc4x4::kIfcStateEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 is specified as a series of discrete load points.*/ kIfcStructuralCurveActivityTypeEnum_DISCRETE, /** 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 linearly distributed over the load's extent.*/ kIfcStructuralCurveActivityTypeEnum_LINEAR, /** The load value is distributed as a half wave described by a symmetric quadratic parabola.*/ kIfcStructuralCurveActivityTypeEnum_PARABOLA, /** The load consists of several consecutive linear sections.*/ kIfcStructuralCurveActivityTypeEnum_POLYGONAL, /** The load value is distributed as a sinus half wave.*/ kIfcStructuralCurveActivityTypeEnum_SINUS, /** 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 OdIfc4x4::IfcStructuralCurveActivityTypeEnum& getUnset() { static OdIfc4x4::IfcStructuralCurveActivityTypeEnum nullEnum = OdIfc4x4::kIfcStructuralCurveActivityTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration distinguishes between different types of structural 'curve' members, such as cables. */ enum IfcStructuralCurveMemberTypeEnum { /** A tension member which is able to carry transverse loads only under large deflection.*/ kIfcStructuralCurveMemberTypeEnum_CABLE, /** A member without tensional stiffness.*/ kIfcStructuralCurveMemberTypeEnum_COMPRESSION_MEMBER, /** A member with capacity to carry axial loads only, i.e. a link. Typically used in trusses.*/ kIfcStructuralCurveMemberTypeEnum_PIN_JOINED_MEMBER, /** 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 without compressional stiffness.*/ kIfcStructuralCurveMemberTypeEnum_TENSION_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 OdIfc4x4::IfcStructuralCurveMemberTypeEnum& getUnset() { static OdIfc4x4::IfcStructuralCurveMemberTypeEnum nullEnum = OdIfc4x4::kIfcStructuralCurveMemberTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration defines the distribution of load values in a surface action or reaction. */ enum IfcStructuralSurfaceActivityTypeEnum { /** The load value is bilinearly distributed over the load's extent.*/ kIfcStructuralSurfaceActivityTypeEnum_BILINEAR, /** The load has a constant value over its entire extent.*/ kIfcStructuralSurfaceActivityTypeEnum_CONST, /** 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 OdIfc4x4::IfcStructuralSurfaceActivityTypeEnum& getUnset() { static OdIfc4x4::IfcStructuralSurfaceActivityTypeEnum nullEnum = OdIfc4x4::kIfcStructuralSurfaceActivityTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcStructuralSurfaceMemberTypeEnum& getUnset() { static OdIfc4x4::IfcStructuralSurfaceMemberTypeEnum nullEnum = OdIfc4x4::kIfcStructuralSurfaceMemberTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcSubContractResourceTypeEnum& getUnset() { static OdIfc4x4::IfcSubContractResourceTypeEnum nullEnum = OdIfc4x4::kIfcSubContractResourceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration indicates the type of a surface feature. */ enum IfcSurfaceFeatureTypeEnum { /** Detected defect on the surface of an element, such as corroded or eroded area.*/ kIfcSurfaceFeatureTypeEnum_DEFECT, /** surface markings defined by enclosed 2d shape with defined hatch fillings.*/ kIfcSurfaceFeatureTypeEnum_HATCHMARKING, /** 2D lines painted on pavement surfaces to form boundaries, centerlines and edge markings.*/ kIfcSurfaceFeatureTypeEnum_LINEMARKING, /** A point, line, cross, or other mark, applied for example for easier adjustment of elements during assembly.*/ kIfcSurfaceFeatureTypeEnum_MARK, /** Paint or surfacing to prevent sliding or skidding.*/ kIfcSurfaceFeatureTypeEnum_NONSKIDSURFACING, /** Painted or chemical lines or symbols on the surface of pavements (a road or paved area)*/ kIfcSurfaceFeatureTypeEnum_PAVEMENTSURFACEMARKING, /** Raised and often textured strips on road center line or on shoulder, or across lanes to alert drivers by vibration and noise. Also Jiggle bars.*/ kIfcSurfaceFeatureTypeEnum_RUMBLESTRIP, /** Surface markings that convey information in the form of symbols and shapes such as arrows, text or pictorial symbols.*/ kIfcSurfaceFeatureTypeEnum_SYMBOLMARKING, /** 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, /** Type of rumble strip running across lane(s).*/ kIfcSurfaceFeatureTypeEnum_TRANSVERSERUMBLESTRIP, /** 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, /** 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 OdIfc4x4::IfcSurfaceFeatureTypeEnum& getUnset() { static OdIfc4x4::IfcSurfaceFeatureTypeEnum nullEnum = OdIfc4x4::kIfcSurfaceFeatureTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details IfcSurfaceSide is a denotion of whether negative, positive or both sides of a surface are being referenced. */ enum IfcSurfaceSide { /** Both, positive and negative side.*/ kIfcSurfaceSide_BOTH, /** The side of a surface which is in the opposite direction than the surface normal derived from the mathematical definition.*/ kIfcSurfaceSide_NEGATIVE, /** The side of a surface which is in the same direction as the surface normal derived from the mathematical definition.*/ kIfcSurfaceSide_POSITIVE, /** The value is unset.*/ kIfcSurfaceSide_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcSurfaceSide& getUnset() { static OdIfc4x4::IfcSurfaceSide nullEnum = OdIfc4x4::kIfcSurfaceSide_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 device designed to produce sudden predetermined changes in one or more electric output circuits, when certain conditions are fulfilled in the electric input circuits controlling the device.*/ kIfcSwitchingDeviceTypeEnum_RELAY, /** 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 for alternatively closing and opening one or more electric circuits.*/ kIfcSwitchingDeviceTypeEnum_START_AND_STOP_EQUIPMENT, /** 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 OdIfc4x4::IfcSwitchingDeviceTypeEnum& getUnset() { static OdIfc4x4::IfcSwitchingDeviceTypeEnum nullEnum = OdIfc4x4::kIfcSwitchingDeviceTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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, /** A subrack is a part of technical cabinet which is used to store and mount pluggable electric subunits.*/ kIfcSystemFurnitureElementTypeEnum_SUBRACK, /** 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 OdIfc4x4::IfcSystemFurnitureElementTypeEnum& getUnset() { static OdIfc4x4::IfcSystemFurnitureElementTypeEnum nullEnum = OdIfc4x4::kIfcSystemFurnitureElementTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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, /** An open container for environmental protection and storage of chemical products.*/ kIfcTankTypeEnum_OILRETENTIONTRAY, /** 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 OdIfc4x4::IfcTankTypeEnum& getUnset() { static OdIfc4x4::IfcTankTypeEnum nullEnum = OdIfc4x4::kIfcTankTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcTaskDurationEnum& getUnset() { static OdIfc4x4::IfcTaskDurationEnum nullEnum = OdIfc4x4::kIfcTaskDurationEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details The IfcTaskTypeEnum defines the range of different types of task that can be specified. */ enum IfcTaskTypeEnum { /** Making changes to the physical configuration of something.*/ kIfcTaskTypeEnum_ADJUSTMENT, /** Attendance or waiting on other things happening.*/ kIfcTaskTypeEnum_ATTENDANCE, /** Making changes to the operational configuration of something.*/ kIfcTaskTypeEnum_CALIBRATION, /** 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, /** Tasks required when responding to, or ensuring the ability to respond to, an emergency situation.*/ kIfcTaskTypeEnum_EMERGENCY, /** Check if something is installed and is operating within expected parameters.*/ kIfcTaskTypeEnum_INSPECTION, /** 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, /** Tasks required to ensure safe use of the object. For example electrical 'lock-out' instructions.*/ kIfcTaskTypeEnum_SAFETY, /** The set of tasks required for an orderly shut down without adverse impacts, typically applied to systems.*/ kIfcTaskTypeEnum_SHUTDOWN, /** The set of tasks required to begin or restart operation without adverse impacts, typically applied to systems.*/ kIfcTaskTypeEnum_STARTUP, /** The set of tasks required to evaluate the performance of an object, to ensure if something is installed and is operating within expected parameters.*/ kIfcTaskTypeEnum_TESTING, /** The set of tasks required to diagnose commonly encountered performance problems, typically applied to element types and systems.*/ kIfcTaskTypeEnum_TROUBLESHOOTING, /** User defined.*/ kIfcTaskTypeEnum_USERDEFINED, /** Undefined.*/ kIfcTaskTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcTaskTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcTaskTypeEnum& getUnset() { static OdIfc4x4::IfcTaskTypeEnum nullEnum = OdIfc4x4::kIfcTaskTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcTendonAnchorTypeEnum& getUnset() { static OdIfc4x4::IfcTendonAnchorTypeEnum nullEnum = OdIfc4x4::kIfcTendonAnchorTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details Enumerations of Tendon Conduit Types. */ enum IfcTendonConduitTypeEnum { /** A part to connect the conduits located in two different deck segments and related to the same tendon.*/ kIfcTendonConduitTypeEnum_COUPLER, /** A part of tendon conduit associated to deviator.*/ kIfcTendonConduitTypeEnum_DIABOLO, /** 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, /** 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, /** 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 OdIfc4x4::IfcTendonConduitTypeEnum& getUnset() { static OdIfc4x4::IfcTendonConduitTypeEnum nullEnum = OdIfc4x4::kIfcTendonConduitTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcTendonTypeEnum& getUnset() { static OdIfc4x4::IfcTendonTypeEnum nullEnum = OdIfc4x4::kIfcTendonTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details The text path determines the direction of the text characters in respect to each other. */ enum IfcTextPath { /** Down*/ kIfcTextPath_DOWN, /** Left*/ kIfcTextPath_LEFT, /** Right*/ kIfcTextPath_RIGHT, /** Up*/ kIfcTextPath_UP, /** The value is unset.*/ kIfcTextPath_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcTextPath& getUnset() { static OdIfc4x4::IfcTextPath nullEnum = OdIfc4x4::kIfcTextPath_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcTimeSeriesDataTypeEnum& getUnset() { static OdIfc4x4::IfcTimeSeriesDataTypeEnum nullEnum = OdIfc4x4::kIfcTimeSeriesDataTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details Enumeration of Track Elements types. */ enum IfcTrackElementTypeEnum { /** A device composed of pneumatic, mechanic or electric components causing the braking of a train in case of emergency.*/ kIfcTrackElementTypeEnum_BLOCKINGDEVICE, /** A fixed device which, when placed on the rail, derails the wheels of a vehicle, and serves to protect a converging line.*/ kIfcTrackElementTypeEnum_DERAILER, /** A frog is an arrangement ensuring the intersection of two opposite running edges of turnouts or diamond crossings and having one crossing vee and two wing rails.*/ kIfcTrackElementTypeEnum_FROG, /** A half set of blades consists of one stock rail and its switch rail complete with small fittings. It is right or left hand as seen by an observer in the centre of the track facing the switch heel from the switch toe.*/ kIfcTrackElementTypeEnum_HALF_SET_OF_BLADES, /** A sleeper is a track element that supports running rails, guard rails and check rails usually at right angles to its axis.*/ kIfcTrackElementTypeEnum_SLEEPER, /** A device composed of pneumatic, mechanic or electric components causing the breaking of a train in case of emergency.*/ kIfcTrackElementTypeEnum_SPEEDREGULATOR, /** A track end of alignment is a special functional installation such as axle-gauge changeover point or transporter wagon loading point.*/ kIfcTrackElementTypeEnum_TRACKENDOFALIGNMENT, /** A fixed installation at the end of the track which stops any vehicle movement (e.g., buffer stop, sand hump, etc.).*/ kIfcTrackElementTypeEnum_VEHICLESTOP, /** User-defined type*/ kIfcTrackElementTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcTrackElementTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcTrackElementTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcTrackElementTypeEnum& getUnset() { static OdIfc4x4::IfcTrackElementTypeEnum nullEnum = OdIfc4x4::kIfcTrackElementTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details The IfcTransformerTypeEnum defines the range of different types of transformer that can be specified. */ enum IfcTransformerTypeEnum { /** A chopper is an electronic power DC convertor without an intermediate AC link giving a variable output voltage by varying the periods of conduction and non-conduction in an adjustable ratio.*/ kIfcTransformerTypeEnum_CHOPPER, /** A transformer that changes different quantities between circuits.*/ kIfcTransformerTypeEnum_COMBINED, /** 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 OdIfc4x4::IfcTransformerTypeEnum& getUnset() { static OdIfc4x4::IfcTransformerTypeEnum nullEnum = OdIfc4x4::kIfcTransformerTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details The IfcTransitionCode indicated the continuity between consecutive segments of a curve or surface. */ enum IfcTransitionCode { /** 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 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 value is unset.*/ kIfcTransitionCode_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcTransitionCode& getUnset() { static OdIfc4x4::IfcTransitionCode nullEnum = OdIfc4x4::kIfcTransitionCode_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration is used to identify primary transport element types. */ enum IfcTransportElementTypeEnum { /** 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, /** 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, /** A device used for hauling goods.*/ kIfcTransportElementTypeEnum_HAULINGGEAR, /** A device used for lifting or lowering heavy goods. It may be manually operated or electrically or pneumatically driven.*/ kIfcTransportElementTypeEnum_LIFTINGGEAR, /** Moving walkway being a transport device to move people horizontally or on an incline. It is a slow conveyor belt that transports people.*/ kIfcTransportElementTypeEnum_MOVINGWALKWAY, /** User-defined type.*/ kIfcTransportElementTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcTransportElementTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcTransportElementTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcTransportElementTypeEnum& getUnset() { static OdIfc4x4::IfcTransportElementTypeEnum nullEnum = OdIfc4x4::kIfcTransportElementTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcTrimmingPreference& getUnset() { static OdIfc4x4::IfcTrimmingPreference nullEnum = OdIfc4x4::kIfcTrimmingPreference_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcTubeBundleTypeEnum& getUnset() { static OdIfc4x4::IfcTubeBundleTypeEnum nullEnum = OdIfc4x4::kIfcTubeBundleTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { enum IfcTunnelPartTypeEnum { kIfcTunnelPartTypeEnum_CROSSWAY, kIfcTunnelPartTypeEnum_PORTAL, kIfcTunnelPartTypeEnum_RINGSECTION, kIfcTunnelPartTypeEnum_TUNNELSECTION, kIfcTunnelPartTypeEnum_USERDEFINED, kIfcTunnelPartTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcTunnelPartTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcTunnelPartTypeEnum& getUnset() { static OdIfc4x4::IfcTunnelPartTypeEnum nullEnum = OdIfc4x4::kIfcTunnelPartTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { enum IfcTunnelTypeEnum { kIfcTunnelTypeEnum_ACCESSTUNNEL, kIfcTunnelTypeEnum_BICYCLE, kIfcTunnelTypeEnum_BYPASS, kIfcTunnelTypeEnum_MAINTENANCE, kIfcTunnelTypeEnum_METRO, kIfcTunnelTypeEnum_PEDESTRIAN, kIfcTunnelTypeEnum_RAILWAY, kIfcTunnelTypeEnum_RAMP, kIfcTunnelTypeEnum_ROAD, kIfcTunnelTypeEnum_SHAFT, kIfcTunnelTypeEnum_UNDERGROUND_FACILITIES, kIfcTunnelTypeEnum_UTILITIES, kIfcTunnelTypeEnum_USERDEFINED, kIfcTunnelTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcTunnelTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcTunnelTypeEnum& getUnset() { static OdIfc4x4::IfcTunnelTypeEnum nullEnum = OdIfc4x4::kIfcTunnelTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { enum IfcTunnelTypicalSectionTypeEnum { kIfcTunnelTypicalSectionTypeEnum_EXCAVATIONSUPPORT, kIfcTunnelTypicalSectionTypeEnum_GEOTECH, kIfcTunnelTypicalSectionTypeEnum_RISK, kIfcTunnelTypicalSectionTypeEnum_USERDEFINED, kIfcTunnelTypicalSectionTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcTunnelTypicalSectionTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcTunnelTypicalSectionTypeEnum& getUnset() { static OdIfc4x4::IfcTunnelTypicalSectionTypeEnum nullEnum = OdIfc4x4::kIfcTunnelTypicalSectionTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcUnitEnum& getUnset() { static OdIfc4x4::IfcUnitEnum nullEnum = OdIfc4x4::kIfcUnitEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 base station controller (BSC) is a network component with the functions for controlling one or more base transceiver stations. BSC is responsible for the management of various interfaces, wireless resources and parameters, the signalling processing of call establishment and the channel allocation in the cell.*/ kIfcUnitaryControlElementTypeEnum_BASESTATIONCONTROLLER, /** Combination of at least two predefined types of unitary control element.*/ kIfcUnitaryControlElementTypeEnum_COMBINED, /** 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 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 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 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 OdIfc4x4::IfcUnitaryControlElementTypeEnum& getUnset() { static OdIfc4x4::IfcUnitaryControlElementTypeEnum nullEnum = OdIfc4x4::kIfcUnitaryControlElementTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details Enumeration defining the functional type of unitary equipment. */ enum IfcUnitaryEquipmentTypeEnum { /** A unitary packaged air-conditioning unit typically used in residential or light commercial applications.*/ kIfcUnitaryEquipmentTypeEnum_AIRCONDITIONINGUNIT, /** A unitary air handling unit typically containing a fan, economizer, and coils.*/ kIfcUnitaryEquipmentTypeEnum_AIRHANDLER, /** A unitary packaged dehumidification unit. Note: units supporting multiple modes (dehumidification, cooling, and/or heating) should use AIRCONDITIONINGUNIT.*/ kIfcUnitaryEquipmentTypeEnum_DEHUMIDIFIER, /** 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, /** A system which separates the compressor from the evaporator, but acts as a unitary component typically within residential or light commercial applications.*/ kIfcUnitaryEquipmentTypeEnum_SPLITSYSTEM, /** 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 OdIfc4x4::IfcUnitaryEquipmentTypeEnum& getUnset() { static OdIfc4x4::IfcUnitaryEquipmentTypeEnum nullEnum = OdIfc4x4::kIfcUnitaryEquipmentTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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, /** 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, /** A valve used to remove fluid from a piping system.*/ kIfcValveTypeEnum_DRAWOFFCOCK, /** 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 OdIfc4x4::IfcValveTypeEnum& getUnset() { static OdIfc4x4::IfcValveTypeEnum nullEnum = OdIfc4x4::kIfcValveTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration is used to identify non-fixed or mobile transport element types. */ enum IfcVehicleTypeEnum { /** A mobile transport element that represents a discrete unit of cargo managed by a facility.*/ kIfcVehicleTypeEnum_CARGO, /** Refers to railway vehicles, including both powered and unpowered vehicles, for example locomotives, railroad cars, coaches, private railroad cars and wagons.*/ kIfcVehicleTypeEnum_ROLLINGSTOCK, /** A generalisation of a vehicle that interacts with a facility (e.g. as a user/customer) or as a specified operational asset within the facility.*/ kIfcVehicleTypeEnum_VEHICLE, /** A specialisation of a vehicle that represents powered and unpowered flying vehicles, such as airplanes, helicopters, gliders etc.*/ kIfcVehicleTypeEnum_VEHICLEAIR, /** A specialisation of a vehicle that operates on water as a marine vessel.*/ kIfcVehicleTypeEnum_VEHICLEMARINE, /** A specialisation of a vehicle that operates on land tracked (Caterpillar).*/ kIfcVehicleTypeEnum_VEHICLETRACKED, /** A specialisation of a vehicle that operates on land as a multi wheeled vehicle such as a car, lorry, forklift etc.*/ kIfcVehicleTypeEnum_VEHICLEWHEELED, /** User-defined type.*/ kIfcVehicleTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcVehicleTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcVehicleTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcVehicleTypeEnum& getUnset() { static OdIfc4x4::IfcVehicleTypeEnum nullEnum = OdIfc4x4::kIfcVehicleTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 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, /** 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, /** The friction type is a damper utilizing friction acting on the contact surface of a material.*/ kIfcVibrationDamperTypeEnum_FRICTION, /** 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, /** 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, /** The viscous type is a damper that absorbs energy by utilizing the resistance of a viscous body.*/ kIfcVibrationDamperTypeEnum_VISCOUS, /** 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 OdIfc4x4::IfcVibrationDamperTypeEnum& getUnset() { static OdIfc4x4::IfcVibrationDamperTypeEnum nullEnum = OdIfc4x4::kIfcVibrationDamperTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details Enumeration defining the typical types of vibration isolators. */ enum IfcVibrationIsolatorTypeEnum { /** Base isolator preventing transfer of energy from the ground to the structure.*/ kIfcVibrationIsolatorTypeEnum_BASE, /** Compression type vibration isolator.*/ kIfcVibrationIsolatorTypeEnum_COMPRESSION, /** Spring type vibration isolator.*/ kIfcVibrationIsolatorTypeEnum_SPRING, /** User-defined vibration isolator type.*/ kIfcVibrationIsolatorTypeEnum_USERDEFINED, /** Undefined vibration isolator type.*/ kIfcVibrationIsolatorTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcVibrationIsolatorTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcVibrationIsolatorTypeEnum& getUnset() { static OdIfc4x4::IfcVibrationIsolatorTypeEnum nullEnum = OdIfc4x4::kIfcVibrationIsolatorTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details Enumeration of Virtual Element Types. */ enum IfcVirtualElementTypeEnum { /** An imaginary boundary, such as between two adjacent spaces that are not separated by a physical boundary.*/ kIfcVirtualElementTypeEnum_BOUNDARY, /** The virtual element denotes a clearance area or volume.*/ kIfcVirtualElementTypeEnum_CLEARANCE, /** The virtual element denotes a proposed provision for voids (an proposed opening not applied as void yet).*/ kIfcVirtualElementTypeEnum_PROVISIONFORVOID, /** User-defined type.*/ kIfcVirtualElementTypeEnum_USERDEFINED, /** Undefined type.*/ kIfcVirtualElementTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcVirtualElementTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcVirtualElementTypeEnum& getUnset() { static OdIfc4x4::IfcVirtualElementTypeEnum nullEnum = OdIfc4x4::kIfcVirtualElementTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration qualifies a voiding feature regarding its shape and configuration relative to the voided element. */ enum IfcVoidingFeatureTypeEnum { /** A skewed plane end cut, removing material only across a part of the profile of the voided element.*/ kIfcVoidingFeatureTypeEnum_CHAMFER, /** 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, /** 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 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, /** 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 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 OdIfc4x4::IfcVoidingFeatureTypeEnum& getUnset() { static OdIfc4x4::IfcVoidingFeatureTypeEnum nullEnum = OdIfc4x4::kIfcVoidingFeatureTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration defines the different types of walls that can further specify an IfcWall or IfcWallType. */ enum IfcWallTypeEnum { /** A stud wall framed with studs and faced with sheetings, sidings, wallboard, or plasterwork.*/ kIfcWallTypeEnum_ELEMENTEDWALL, /** 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 polygonal wall, extruded vertically, where the wall thickness varies along the wall path.*/ kIfcWallTypeEnum_POLYGONAL, /** 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, /** 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, /** Protective wall or screen to block overtopping and impact of waves across a breakwater*/ kIfcWallTypeEnum_WAVEWALL, /** User-defined wall element.*/ kIfcWallTypeEnum_USERDEFINED, /** Undefined wall element.*/ kIfcWallTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcWallTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcWallTypeEnum& getUnset() { static OdIfc4x4::IfcWallTypeEnum nullEnum = OdIfc4x4::kIfcWallTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcWasteTerminalTypeEnum& getUnset() { static OdIfc4x4::IfcWasteTerminalTypeEnum nullEnum = OdIfc4x4::kIfcWasteTerminalTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration defines the basic ways to describe how window panels operate. */ enum IfcWindowPanelOperationEnum { /** Panel is bottom hung.*/ kIfcWindowPanelOperationEnum_BOTTOMHUNG, /** Panel is fixed.*/ kIfcWindowPanelOperationEnum_FIXEDCASEMENT, /** Other.*/ kIfcWindowPanelOperationEnum_OTHEROPERATION, /** Panel is swinging horizontally (hinges are in the middle).*/ kIfcWindowPanelOperationEnum_PIVOTHORIZONTAL, /** Panel is swinging vertically (hinges are in the middle).*/ kIfcWindowPanelOperationEnum_PIVOTVERTICAL, /** Panel is removable.*/ kIfcWindowPanelOperationEnum_REMOVABLECASEMENT, /** Panel that opens to the left when viewed from the outside.*/ kIfcWindowPanelOperationEnum_SIDEHUNGLEFTHAND, /** Panel that opens to the right when viewed from the outside.*/ kIfcWindowPanelOperationEnum_SIDEHUNGRIGHTHAND, /** Panel is sliding horizontally.*/ kIfcWindowPanelOperationEnum_SLIDINGHORIZONTAL, /** Panel is sliding vertically.*/ kIfcWindowPanelOperationEnum_SLIDINGVERTICAL, /** Panel that opens to the left and is bottom hung.*/ kIfcWindowPanelOperationEnum_TILTANDTURNLEFTHAND, /** Panel that opens to the right and is bottom hung.*/ kIfcWindowPanelOperationEnum_TILTANDTURNRIGHTHAND, /** Panel is top hung.*/ kIfcWindowPanelOperationEnum_TOPHUNG, /** Undefined.*/ kIfcWindowPanelOperationEnum_NOTDEFINED, /** The value is unset.*/ kIfcWindowPanelOperationEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcWindowPanelOperationEnum& getUnset() { static OdIfc4x4::IfcWindowPanelOperationEnum nullEnum = OdIfc4x4::kIfcWindowPanelOperationEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 { /** Bottom*/ kIfcWindowPanelPositionEnum_BOTTOM, /** Left*/ kIfcWindowPanelPositionEnum_LEFT, /** Middle*/ kIfcWindowPanelPositionEnum_MIDDLE, /** Right*/ kIfcWindowPanelPositionEnum_RIGHT, /** Top*/ kIfcWindowPanelPositionEnum_TOP, /** Undefined.*/ kIfcWindowPanelPositionEnum_NOTDEFINED, /** The value is unset.*/ kIfcWindowPanelPositionEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcWindowPanelPositionEnum& getUnset() { static OdIfc4x4::IfcWindowPanelPositionEnum nullEnum = OdIfc4x4::kIfcWindowPanelPositionEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \details This enumeration defines the different predefined types of windows that can further specify an IfcWindow or IfcWindowType. */ enum IfcWindowTypeEnum { /** A special window that lies horizonally in a roof slab opening.*/ kIfcWindowTypeEnum_LIGHTDOME, /** A window within a sloped building element, usually a roof slab.*/ kIfcWindowTypeEnum_SKYLIGHT, /** A standard window usually within a wall opening, as a window panel in a curtain wall, or as a "free standing" window.*/ kIfcWindowTypeEnum_WINDOW, /** User-defined window element.*/ kIfcWindowTypeEnum_USERDEFINED, /** Undefined window element.*/ kIfcWindowTypeEnum_NOTDEFINED, /** The value is unset.*/ kIfcWindowTypeEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcWindowTypeEnum& getUnset() { static OdIfc4x4::IfcWindowTypeEnum nullEnum = OdIfc4x4::kIfcWindowTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 two panels. The configuration of the panels is horizontally.*/ kIfcWindowTypePartitioningEnum_DOUBLE_PANEL_HORIZONTAL, /** Window with two panels. The configuration of the panels is vertically.*/ kIfcWindowTypePartitioningEnum_DOUBLE_PANEL_VERTICAL, /** Window with one panel.*/ kIfcWindowTypePartitioningEnum_SINGLE_PANEL, /** 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 the panels is horizontally.*/ kIfcWindowTypePartitioningEnum_TRIPLE_PANEL_HORIZONTAL, /** 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 two panels is vertically and the third one is horizontally at the top.*/ kIfcWindowTypePartitioningEnum_TRIPLE_PANEL_TOP, /** Window with three panels. The configuration of the panels is vertically.*/ kIfcWindowTypePartitioningEnum_TRIPLE_PANEL_VERTICAL, /** User defined operation type.*/ kIfcWindowTypePartitioningEnum_USERDEFINED, /** No description available.*/ kIfcWindowTypePartitioningEnum_NOTDEFINED, /** The value is unset.*/ kIfcWindowTypePartitioningEnum_unset }; } namespace OdDAI { namespace Utils { template <> inline const OdIfc4x4::IfcWindowTypePartitioningEnum& getUnset() { static OdIfc4x4::IfcWindowTypePartitioningEnum nullEnum = OdIfc4x4::kIfcWindowTypePartitioningEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcWorkCalendarTypeEnum& getUnset() { static OdIfc4x4::IfcWorkCalendarTypeEnum nullEnum = OdIfc4x4::kIfcWorkCalendarTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcWorkPlanTypeEnum& getUnset() { static OdIfc4x4::IfcWorkPlanTypeEnum nullEnum = OdIfc4x4::kIfcWorkPlanTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { /** \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 OdIfc4x4::IfcWorkScheduleTypeEnum& getUnset() { static OdIfc4x4::IfcWorkScheduleTypeEnum nullEnum = OdIfc4x4::kIfcWorkScheduleTypeEnum_unset; return nullEnum; } } } namespace OdIfc4x4 { } // namespace #include "TD_PackPop.h" #endif // _IFC4X4_ENUM_H